Essential Complexity

Modernizing high-risk systems in the age of AI.

• 4 min read

Three Percent Ruby

DHH wrote half as much code in 7 months as in the previous 21 years. Only 3% of it was Ruby. Aaron Patterson said he's going to keep reading the code. Both are right. Neither answer lasts.

Three Percent Ruby
Joe Leo
Joe Leo

Founder, Def Method

At Rails World last week, Rails creator and provocateur David Heinemeier Hansson told a room of Rails developers he'd written about half as much code in the last seven months as in the previous twenty-one years, and that roughly three percent of it was Ruby. Rust got most of the rest, and he said why: Rust is amazing if you "never, ever, ever have to look at it yourself." Aaron Patterson closed the same conference by saying he's going to keep reading the code.

This is an argument about speed of adoption, trust, and delegating code-writing to AI agents. It's also an argument about where we humans fit as the creators of theory.

In 1985, Peter Naur wrote that the real product of a software team is a theory of the program, the shared understanding that lets people explain what the system does, defend its shape, and answer questions about its behavior. Code is evidence of a theory. You can't reconstruct one from the other. Understanding is one of the principles of GUIDE that I keep coming back to. Once you identify how Understanding is shifting in our industry, you'll see it everywhere. And with identification comes the power to act.

In that light, Patterson advocates reading the code to maintain the theory of a program in a traditional sense. By contrast, DHH is describing a way of working in which nobody acquires that theory.

Exalt Beautiful Code?

Ruby creator Matz offered a language optimized for programmer happiness, and Rails layers convention on top. Open an app you've never seen and find your way around, because app/models is where models live and belongs_to does what it always has. That's convention over configuration, part of The Rails Doctrine authored by DHH. The Doctrine also includes sections called "Optimize for programmer happiness" and "Exalt beautiful code."

All of this was crafted in the days where only humans wrote code. But during Rails World I saw and heard many people trying to retrofit these arguments to suit agentic coding. For example, the claim that Rails suits agentic coding because of convention over configuration is often proffered as a reason for Rails to go on existing.

Agents do better in a constrained environment, and that's a real advantage. I'm not sure it gets us as far as we may hope. Convention is a locator, not a theory-builder. Naming and placement are constrained. Reasons aren't, and reasons are the whole of the theory. And beautiful code is no advantage if no one is looking at it.

Arguing for Understanding

When Aaron Patterson declares, "I'm going to keep reading the code" in a closing keynote to a room full of Rails developers, it's a position offered for adoption. DHH is louder and built more shock into his telling, but both of them are telling the industry what to do. Take the strongest version of each. Aaron's isn't "read everything, however much of it arrives." It's "generate only what you can read," which turns reading into a governor on how fast you're willing to move. DHH's isn't "never look at anything." It's "the tooling is good enough now that looking has stopped paying for itself."

My position is that neither one of these workflows will last, though either might be correct depending on the work you're doing today. DHH's evidence for his position is the Swiss cheese story. He handed final features to designers to vibe-code, looked at the architecture that came out, found it full of holes, shipped it anyway, and treated the shipping as proof the tooling had arrived. That's the wrong test. Shipping tells you the code behaved correctly on the paths you exercised. Whether anyone can explain why it's built that way, or predict what will break when it changes, is a separate question, and we are out of practice asking it. A system can now pass every check you have while nobody on the team can account for its shape, and no stage in your pipeline reports the difference. Naur has a phrase for this: the "death of a program." Once humans cease to collectively hold the theory of a program, that program is dead. A dead program keeps running, keeps serving traffic, keeps producing useful results, but becomes a thing nobody can safely change.

Aaron's position is laudable at a time when everything moves too fast. But if you hold code generation down to human reading speed, teams that don't will out-ship you. Pressure to change course will build every quarter. Reading every line is a defensible though receding practice today. In time, this position will become untenable. Moreover, reading code is just one mechanism for Understanding. For fifty years you couldn't ship without a human sitting down and writing the thing, and that person came away holding a theory of it as a side effect of the work. The theory arrived free with the implementation. Arguing about whether to keep the mechanism is arguing about a proxy, and however that argument comes out, the Understanding still has to come from somewhere.

What It Costs

Giving up the reading is a legitimate decision, and for some systems it's the right one. But the decision isn't free. That's Understanding in action: when agents write the code, your team does not acquire a theory of it as a byproduct of having built it. The theory has to be built in another way and it has to be funded, intentional, and kept current. It's a different kind of work than either DHH or Patterson is describing, and nobody at Rails World had it on a roadmap.

So here's the question to take back to your team. Which parts of your system could someone explain and defend right now, cold, without opening a file? Compare that list to the one you'd have written two years ago. Whatever the gap is, your organization already chose it while it was busy shipping. Start there.

Need to modernize a high-stakes system?

GUIDE is Def Method's framework for preserving understanding, strengthening governance, and building evidence before implementation accelerates.

If this was useful, you might enjoy Essential Complexity — a bi-weekly letter on modernizing high-risk systems in the age of AI.