The same argument, three times

In 1957, programmers did not trust the FORTRAN compiler. Backus’s team had to prove the generated assembly was as fast as assembly written by hand. It was. Everyone stopped reading assembly, except the specialists who kept checking the stack for everyone else.

The same thing happened with Java and the JIT a generation later. Machine code became something most developers could ignore.

When someone says an LLM is basically the next compiler, I get where they are coming from. That argument has already won twice.

But there is one difference I cannot get past: which artifact do you keep?

With a compiler, we keep the source and throw away the output. The transformation is constrained and repeatable. A relatively small group keeps testing the compiler, its optimizers, and the surrounding toolchain. Everyone else inherits that trust.

The trust amortizes. It is built at the tool level and reused across builds and teams.

Determinism is part of the difference, but it is not the whole argument. A compiler stays within a constrained transformation. An LLM makes a new choice each time it generates.

With an LLM, the direction flips. The prompt may survive, but it is not a durable specification of the system. It cannot reliably reproduce the same codebase. The output becomes the thing somebody has to review, test, debug, and live with for years.

The model’s correctness does not amortize the way compiler trust does. The surrounding engineering can: tests, types, constraints, review rules, and a clear record of decisions. But every new generation still has to pass through that system.

The discussion under the shorter LinkedIn version sharpened the question.

Mark Armstrong pointed out that the human mind has always been the nondeterministic layer, and that code may be the source of truth simply because it is the one artifact we consistently preserve. Requirements drift. Specifications stop being maintained. People leave. The code remains because it still has to match the running system. AI does not create that problem. It adds another layer between our understanding and the artifact that survives.

Dov Keshet put it in one line: “The source survived, the reasoning didn’t.”

That changes the split. It is not generated code against code written by a person. It is an artifact that remains connected to the running system against one that disappears or can no longer be trusted.

That is the whole argument. Not that the tools are bad. They are useful and getting better. Not that generated code is necessarily worse than code written by a person. Only that cheaper generation does not remove the cost of verification, context, and ownership.

I use AI tools every day. Maybe one day generating software will be as boring and reliable as compiling it. Until then, responsibility stays where it always was, with the person whose name is on the system.

These days, that person is often me.

A shorter version was published on LinkedIn on 11 August 2026. This version grew out of the discussion there and is the canonical one.