Describe what you want to an AI coding tool and there is something working on screen within minutes. It looks close to done. But making it actually done is where the time goes, and that stretch takes a lot longer than the fast bit made you expect.
Addy Osmani, who runs developer experience for Chrome at Google, named this in late 2024. AI gets you about 70% of the way to a working solution very fast. Addy put it at 70% in 2024, but it is probably 80% today. It doesn't really change the big picture: the remaining 20% is still an exercise in diminishing returns.
Nobody should treat these percentages as exact science, the shape is what matters: the part AI does quickly was never the expensive part, and the part it still struggles with is the part that always cost the most.
Why companies are pricing AI coding wrong
Most companies are pricing this wrong. The assumption is that AI compresses the whole job, so code appearing three times faster means delivery three times faster. In reality the cheap 80% gets cheaper while the expensive 20% stays expensive or gets worse. Osmani's conclusion is blunt: software quality was probably never limited by how fast people could type, so typing faster does not make the software better. Understanding what to build, designing something that survives real users, handling edge cases, keeping it secure… is the hard part.
The knowledge that never gets written down
Why does the last 20% sometimes get worse, rather than just staying the same? A person writing code carries the reasoning in their head. Why this approach and not that one, what the tricky trade-off was, which incident three years ago explains the odd-looking retry logic. Ask them and they will tell you, even if none of it was written down. When AI writes it, there was no one thinking it through, so there is nothing to ask about later.
A recent engineering piece from a couple of months ago explains it well. AI generates documentation happily, but it can only document what the code does, not the why. "Uses exponential backoff" is easy. "Uses exponential backoff because the upstream API rate-limits us after three rapid retries, which took down production last November" is the sentence that saves you at two in the morning, and it does not exist. Not in the code, not in the comments, and not in anyone's memory.
Green tests, missing logic
There is a second trap mentioned in the same piece. AI-generated code can arrive with tests passing and full coverage on the dashboard while the business rule it was meant to enforce is nowhere in it. Green tests, a reassuring number, a real hole underneath. A reviewer skimming for red marks waves it through, because everything designed to catch problems is reporting that there is nothing to catch.
Who owns the last 20%?
So the question is not how much faster the team writes code. It is who owns the last 20%, and what it costs when they do.
On a team of experienced engineers the answer is reassuring. AI helps seniors more than juniors, which surprises people who expected it to democratise the work. A senior takes the 80% draft and does what was always the job: refactors it, hardens the edges, questions the shape, puts the reasoning back in. The starting line moved forward. The engineer still runs the hard part of the race. That is a genuine gain and worth having.
The problem is then a last 20% with no owner, or an owner who cannot do it. A junior who accepts the draft because the tests are green has not saved the 20%, only deferred it to a worse moment. Osmani calls the result house of cards code. It stands up beautifully in the demo, wins the room, then falls over the first time a real user does something the happy path did not expect. The cost never went away when the code appeared in minutes. It moved downstream, to production, to an incident, to whoever finally has to understand a system nobody ever understood in the first place.
The organisational mistake
The tools are extraordinary at the 80%, and none of what we described above is a reason to use them less. The mistake is organisational: companies sometimes staff and plan as though the expensive part has been automated, when it is the one part that has not. The teams getting real leverage let AI take the first draft everywhere and stay deliberate about who closes the gap behind it, which usually means keeping experienced people close to the code rather than assuming the tool has made them optional.
What this means for the next generation of engineers
Here is the part that decides how this plays out over years rather than months. Juniors used to earn their experience on the 80% that AI now does. If seniors are the only ones who can reliably do the 20%, the path from junior to senior narrows at exactly the moment the whole model depends on having enough seniors. Companies that are deliberate now about how their people still learn the hard part will have engineers who can own the 20% in five years. The ones treating AI as a reason to hire fewer and expect more may find they have bought a great deal of 80% and nobody left who can finish it.