The Bottleneck Moved : Code Got Cheap, Trust Didn't

I can write more code in a morning than I can trust in a week. Sit with that for a second — because that one gap is the whole story of where software is heading.

For seventy years, writing code was the hard part. That's why we hired engineers, built IDEs, worshipped Stack Overflow, and shipped a new framework every Tuesday. Every tool we ever made pointed at one target: make code cheaper to produce.

We hit the target. Then we blew past it.

Here's the real kicker: producing code was never the expensive part.
Being sure of it was. We just couldn't see that, because for decades the two came bundled — the engineer who wrote the function understood it for free.

That bundle is gone.

The principle underneath is simple. Every system has one real bottleneck at a time. Kill it, and the system doesn't go free — the bottleneck just moves. We spent decades grinding on generation and finally cracked it wide open with AI. The pressure didn't vanish. It relocated. And it landed squarely on verification — knowing the code does what you meant, only what you meant, and won't betray you next Tuesday.

And verification scales horribly.

A model spits out a thousand lines in seconds. Reading those thousand lines still takes you the better part of an hour — and a tired you does it badly.

Worse, the old trick for trusting code is dead. You can't pull a model aside, ask why it made a choice, and watch its face. It'll invent a confident answer on the spot. Confidence is free for the machine. The doubt is all yours.

We've run this experiment before — just not in software.

When factories made goods cheap, the winners weren't the ones who pumped out the most. They were the ones who pumped out reliably. Toyota, not whoever stamped the most metal. Deming nailed it decades ago: you can't inspect quality in at the end of the line. By then it's too late. You build it in.

The discipline that won the 20th century wasn't production. It was verification, pulled upstream until it got cheap.

Software's about to relearn that the hard way.

The next decade belongs to whoever makes trust cheap — not code. Everyone's going to have infinite code; that's table stakes now. The edge goes to whoever can stare at a mountain of generated code and know, fast, which of it to believe:

• Tests you'd actually bet money on.

• Types that make whole classes of bugs impossible to even write.

• Provenance you can trace.

• Feedback in seconds, not a review queue that rots for three days.

Verification pulled upstream until it disappears into the build itself. Same move Deming made on the factory floor.

I've got an unfair advantage seeing this, because I build in regulated fintech.

In Open Banking you're never allowed to just trust the output. Every action needs consent on record, an audit trail, a mandate proving it was allowed, a way to reconstruct exactly what happened and why. Finance figured this out a long time ago: when you're handling things that matter, verification is the product. The ledger isn't where the money lives. It's where the trust lives.

The rest of software is only now waking up to that — dragged there by a flood of code no human ever wrote.

Here's the part I love.

Generation is creativity. Verification is judgment. We just made creativity cheap. The machine will fill a blank screen better than most of us. What it can't do is tell you whether what it wrote is right — or whether it was even the right thing to build.

That's taste. That's judgment. And judgment doesn't get automated, because judgment is the thing that decides whether the automation worked.

So the scarce skill flipped. The old flex was how fast you could ship. The new flex is how cheaply you can be certain.

In a world of infinite code, the rare thing — the thing that compounds — is knowing which code to believe.

That's the bet I'm making. I've stopped chasing faster ways to generate; that race is over, and the prize is racing to zero. The whole game now is the other half — the unglamorous half we ignored the entire time it was cheap.

The bottleneck moved. Most of the industry is still optimizing the part that's already free.

The question stopped being how much you can build.

It's how much you can trust.