The operating languages

Nobody reads compiler output today.

In the eighties, all the good ones did.

When C started eating the world, serious assembly programmers did what any professional does when someone changes their tools: they compiled, opened the result, and read it line by line. And they threw their hands up. Wasted registers, absurd jumps, instructions that didn't need to be there. Worse: they didn't trust the process. To them, the compiler wasn't deterministic. Not in the formal sense, but in the sense that matters when you sign off on a system: you couldn't predict what would come out the other side, and what came out changed with every version and every flag.

Some went further. They refused the middleman and built their own tools, their own assembly, their own hand-tuned routines for the critical paths. It's on the record: the story of Mel, the programmer who distrusted even the assembler, dates from 1983. It's not bar-room legend. It's a documented pattern of how the best talent of a generation reacts when a new layer appears between them and the machine.

And how did it end? The compiler won. But look at how it won, because that's the key to everything else.

It didn't win because programmers learned to love it. It won because trust moved. We stopped trusting our reading of the output and started trusting the verification layer: defined semantics, tests, benchmarks, reproducible builds. The day the compiler optimized better than the average human, the argument was over. Today the only people who read assembly are the ones who write compilers.

The same frame, forty years later

Now look at what's happening with models.

A model writes code and the serious programmer opens the diff and reads it line by line. And throws their hands up. Too many abstractions, a pattern they wouldn't have chosen, code that works but isn't theirs. And the exact same sentence, word for word: "it's just not deterministic".

That's the assembly programmer reading the output of cc in 1985. The same frame with a different date.

And the outcome will be the same. Trust is not going back into reading the code. It's going to move, again, into the verification layer: contracts, evals, traces, approval gates. Which is exactly what a harness is. It's not an AI fashion: it's the move we already made once with compilers, applied to the new translator.

What I'm impatient to see

Here comes the part I actually care about.

Programming languages are interfaces for humans. Readable syntax, variable names, frameworks, linters arguing about commas: all of that exists because the one writing and the one maintaining was a person.

When the one writing and the one maintaining is a model, that entire layer is overhead.

I'm impatient to see models skip the middleman: emit intermediate representations directly, invent their own interpreter, define their own operating languages optimized for generation and verification instead of human reading. Back to assembly, in practice. The full lap back to the starting square, with one difference: this time the guarantee doesn't come from a human reading. It comes from the harness checking.

Readable code will remain wherever human audit is required. Which is not nothing, but it's not everything. The rest will ship in whatever the machine prefers, the same way nobody today demands that their binary be pretty.

WordPress is the other side of the same coin

This same move is happening at another layer, and there you don't even have to wait: you can see it by browsing.

WordPress exists because a human without a programmer needed to edit their website. That's the job it does: an admin panel, plugins, a PHP interpreter running around the clock to serve content that changes twice a month. All that machinery is the human interface to a problem that no longer needs one.

And that interface has a price. Browse for a while with your eyes open and you'll find a thousand vulnerable WordPress sites: PHP versions out of support, plugins abandoned years ago, real businesses serving injected spam without the owner knowing. That's not bad luck. It's the maintenance cost of a layer designed for humans that no human maintains anymore.

When the maintainer is an agent, the right architecture is different: source in a repo, static output, an agent that edits, validates, and deploys. No panel, no runtime waiting for requests, no live attack surface. The opening-hours change that today goes through a plugin with three CVEs is tomorrow a diff with its trace.

WordPress's days are numbered for the same reason hand-written assembly's were: not because it was bad, but because the human interface that justified its existence stops being necessary.

The rule that remains

The two transitions leave the same rule.

Determinism never returns to the language. It moves to the verification layer.

It happened with compilers: we stopped reading the output and built semantics, tests, and reproducible builds. It will happen with models: we'll stop reading every diff and build contracts, evals, and traces. And it will happen with websites: we'll stop administering panels and have agents editing verified source.

The operating language of the future is not meant to be read by you.

It's meant to be checked by the harness.