A photo of Linus Torvalds and Dave Cutler (and Bill Gates) surfaced the other day, and it sparked a wave of nostalgia. Back in college, my favorite book was Inside Windows NT. I was captivated by the sheer elegance of its design - how beautifully components like schedulers, I/O request packets, and structured exception handling were engineered and assembled. Even as a die-hard Linux fan, I had to admit the NT kernel was in a class of its own in some respects. Its I/O Completion Ports (IOCP) were a masterpiece of asynchronous design, years ahead of what Linux would offer with io_uring.

I spent much of my career on Linux, but in my spare time, I’d pore over the leaked NT 4.0 source code. That’s when I came to really recognize the name Dave Cutler. It wasn’t until I read the book Showstoppers! that I got a fuller picture of the man, the mess of ambitious software development, and why the Blue Screen of Death was, in its own way, a way of life in software.

Of course, I’ve seen my share of Linux kernel panics. But for me, the moment Linux truly came into its own was when Linus merged the small KVM module, transforming the kernel into a full-fledged hypervisor. After years of contentious debate with the Xen community about upstreaming, Linus’s swift decision to merge KVM felt decisive. I knew instantly that KVM would be everywhere, and history proved that right.

These kernels represent what I’d call Software 1.0. They were the crown jewels of their time, an era defined by resource scarcity. Every byte of memory and every CPU cycle counted. This constraint bred incredible ingenuity: we had “schedulers” for everything - from the CPU (remember CFS the Completely Fair Scheduler?) to disk I/O (the elevator algorithm, made obsolete by SSDs) to memory management with its virtual memory, page faults, and complex allocators. It was an age of brilliant, intricate machinery.

Then, the landscape shifted. The pioneers were Google with GFS, MapReduce, and BigTable, and the luminary was Jeff Dean. This marked the dawn of Software 2.0: the era of distributed systems. The primary challenge was no longer resource scarcity on a single machine, but fault tolerance across a massive cluster. This gave us arcane but powerful concepts like Raft and Paxos. Soon, the rest of the world followed with Hadoop, HDFS, and Spark, often built on the JVM with its hundreds of tuning parameters and ten-layer-deep factory patterns. This complexity is perfectly captured by Steve Yegge’s famous quote about needing to crawl into “a huge mountain of poop” to fix anything:

“a huge mountain of poop, the biggest mountain you’ve ever seen, and your job is to crawl into the very center of it, every time you need to fix something.”

Admittedly, the industry developed better tools to manage this complexity. Personally, I found my escape hatch. I abandoned the labyrinthine world of C++ template metaprogramming (I had to Google SFINAE just to remember the term) for the stark simplicity of Go. In a previous role, working on an ad server, I made a bet: instead of building a complex distributed cache, I put the entire 2GB dataset in memory on a machine with only 4GB of RAM. It was a gamble that memory prices would fall faster than our business would grow. It certainly worked out. Still, I wondered where we were headed with that “huge mountain.”

For a while, I was skeptical of Andrej Karpathy’s initial “Software 2.0” concept - neural networks as universal function approximators. It felt powerful, but not like a true replacement for traditional code. But his recent reframing of LLMs as the kernel of Software 3.0 is a revelation. Suddenly, there’s a light at the end of the tunnel.

I believe Software 3.0 is about leveraging immense, pre-trained models to solve problems. This isn’t “vibe-driven development”; it’s about structured interaction with a new kind of computational substrate. With well-crafted prompts, context, and tool-use, a call to a text-completion API can achieve what once required navigating that mountain of code. And because the interface is universal - a string of tokens - it’s inherently composable and scalable.

Looking at that photo of Linus and Cutler again, I feel a mix of reverence and a sense of an ending. They are giants who mastered the art of building complex systems from the ground up, bit by bit. The era they defined may be giving way to something entirely new, where the art lies not in crafting the machine, but in conversing with it. The nature of software development is about to change, and with it, perhaps, everything else.

PS: this was written while waiting for Cursor to add some hundred lines of cgo code, and was then “improved” by Gemini. The article feels exactly what I’ve said but is totally unrecognizable.