Code got free. Trust didn’t.

The model is finished. Code is basically free now. The hard part is no longer writing it. The hard part is trusting it enough to ship.

For most of computing history, the expensive thing was the writing. A working program took skill, time, and care, and that cost set the ceiling on how much software you could have. That ceiling is gone. A model will write a plausible version of almost anything you describe, in seconds, for a price that rounds to zero. Generation is done. Push on it more and almost nothing changes.

When the expensive part of a job goes to zero, the constraint does not vanish. It moves. The new one is the question generation never answered and was never meant to: can you trust the code it wrote? That is the whole problem now. It is a trust problem, not a generation problem.

Green checks are not trust

The reflex is to point at the checks. It builds, the tests pass, the linter is quiet, so it is fine. It is not. Compilation proves the code is well formed, not correct. A passing test proves the cases someone remembered to write behave as expected. It says nothing about whether the thing is safe, whether it respects the licenses it pulled in, whether it survives input the author never imagined, or whether a human can still read it in two years. Green checks are necessary. They are nowhere near enough.

Trust is a bigger claim than correctness. It covers where the code came from, what policy it cleared, security, privacy, whether it behaves the same on the next run, and whether you can trace any line back to the intent that asked for it. None of that comes free with generation. All of it has to be established on purpose, after the code exists and before anyone leans on it.

Proof is the thing you sell

Everything people argue about sits downstream of trust. Speed matters only once you trust what got shipped fast. Cost matters only once you trust what the cheaper path produced. Model choice matters only once every model is held to the same bar. Those are real, but they are second order. They stack on top of proof and are worth nothing without it. The first question, the one an enterprise has to answer before it lets a machine write the software it runs on, is whether the output can be trusted at all.

So proof is what we sell, not generation. Generation is a commodity: everyone has it and it keeps getting cheaper. Taking that output and proving it is safe to ship is rare, hard, and exactly what a company needs before it can move. Whoever answers the trust question owns the part of the work that did not get commoditized.

More autonomy means more to prove, never less

It is tempting to assume a more autonomous factory needs less checking, that a mature enough system earns the right to skip the proof. The opposite. Every step up the curve, from assisted to supervised to autonomous, takes a human out of the loop. Every human you remove was a check, and now the machine has to replace it with evidence it produces itself.

An assisted factory can lean on a developer reading every line. An autonomous one ships with nobody reading along, which means it has to prove, on every artifact, that it stayed inside the lines. More autonomy is not less verification. It is more, earlier, automatic, and auditable. The climb toward software no human wrote is really a climb in how much you can prove. The goal is simple to say: ship software no human wrote and still stand behind it. That is the problem worth solving, and it is the one we are building.