Building Without Writing

I ship more software than ever. I write almost none of it.

I describe what I want in plain English. An agent writes the code, runs it, and fixes it. The editor used to be where I did the work. Now it's where I check the work.

That raises an uncomfortable question: if we aren't writing code, does code still matter?

We've run this experiment before. It didn't end the way most people think.

The Digital Clergy

In medieval Europe, Latin was the language of law, scholarship, and the Church. If you needed a contract drafted or scripture read, you went through someone who knew it: a cleric, a scribe, a notary.

For fifty years, software engineers have played that role. A shop owner who wanted a storefront, or a scientist who wanted a climate model, had to hire someone to translate the idea into C++, Java, or Python.

Then the printing press made books cheap, and the Reformation put scripture into German and English. The scribe's monopoly broke.

LLMs are computing's printing press. You state intent in plain language and the agent writes the code. The monopoly is breaking again.

Syntax Was a Tax

For decades we confused writing code with building software. You had to type syntax to make anything, so typing looked like the work. It never was. Syntax was the tax we paid to talk to the machine.

Agents are cutting that tax. The work moves from memory management and boilerplate to architecture, product judgment, and edge cases. From translating to deciding.

Which tempts an easy conclusion: if the machine translates faithfully, why learn the old language at all?

What Actually Happened to Latin

The shift was slow. Newton published the Principia in Latin in 1687, more than two centuries after Gutenberg. Universities, courts, and the Church held on long after ordinary people stopped needing it.

But Latin did shrink. Most lawyers today can't read it and practice just fine. It became a specialist language: rare, valuable, and held by the people closest to the source.

That's the realistic future for code. Fewer people will read it. The ones who can will matter more.

The Neo-Classicists

Programming is splitting in two.

Most people will build in plain language, and that's good. More people making things is a win. A smaller group will still read the machine's language. They'll direct agents most of the time and step into the code when the requirements get subtle or a foundational decision has to be made.

Call them the Neo-Classicists. They won't be paid for typing speed or memorized APIs. They'll be paid for knowing what's true underneath.

Learning to code today isn't preparing for a dying trade. It's joining the few who can read the original.