Somewhere in the last two years, writing code quietly stopped being the expensive part of software. An AI assistant can produce a working feature in an afternoon and a plausible product in a week. What it cannot do is know whether either of them should exist.
Here is the part the industry is still catching up to. Typing was never the bottleneck.
The slow, expensive work has always been the deciding. What your data model claims about your business. Where the boundaries sit. Which features to refuse. What happens when a payment fails halfway through.
The cost of producing code has collapsed. The cost of a wrong decision has not moved at all.
What the demos don't show
AI-generated code has a signature. It is confident, fluent, and tuned to look correct. It handles the happy path beautifully, because the happy path is what you asked for.
The gap between an impressive demo and something you can bill customers for is not the last 20% of the work. It is a different kind of work.
The cases that were never in the prompt
- The cancelled subscription.
- The duplicate webhook.
- The user who belongs to two organisations.
- The payment that fails halfway through.
That list is where products live or die. And there is a quieter problem behind it. When code gets cheap, teams produce far more of it. The bottleneck just moves to reviewing and verifying the pile.
The hidden cost
Ten times the code without ten times the scrutiny is not speed
A team in that position has not sped up. It has automated the production of its own risk.
Where judgment earns its keep
Watch a senior engineer use these tools and the value is obvious. They frame the problem before generating anything. They throw out the plausible-but-wrong answer, because they have seen where it leads. They hold the line on the data model, because that decision outlives every function the machine writes.
In experienced hands this is real leverage. The same judgment, applied faster.
In inexperienced hands it is leverage too, just pointed the other way: a bad decision has never been cheaper to mass-produce.
What you are paying a development team for was never lines of code — it was always knowing which lines should exist, and standing behind them when reality pushes back. That has not changed; it has concentrated. Teams that pair machine speed with senior judgment ship faster and sounder than either could alone; teams that take the speed without the judgment ship their mistakes at machine speed. There is a blunt way to find out which one you are. Take the last significant thing your team shipped and ask who decided the shape of it — not who wrote it. If the honest answer is that nobody did, and it emerged from whatever the tool proposed first, you have found the thing to fix, and it is not a tooling problem.