Essay

The keyboard was never the bottleneck

AI made developers write 180 percent more code. It made them ship about 30 percent more software. That gap is the whole story, and almost everyone is reading the wrong number.

Thirty percent more shipped software is not nothing. It is one of the largest single-tool output gains the industry has on record. But hold it against a near-tripling of the code written, and the question writes itself: where did the other two-thirds go?

The numbers come from a study of more than 100,000 developers by Mert Demirer and colleagues at MIT. As the tools climb from autocomplete to interactive agents to autonomous ones, the volume of code written rises 40, then 140, then 180 percent. Follow that same surge down the pipeline and it decays at every stage: 180 percent more code, 50 percent more projects, 30 percent more actual releases. Writing got three times cheaper. Shipping barely moved.

The friction shows up exactly where you would expect, downstream. Opsera, a company that sells the tooling to govern all of this, benchmarked 250,000 developers and found AI-written pull requests sit in review 4.6 times longer and carry 15 to 18 percent more security holes. GitClear, watching 200 million lines change, found rework, the code you write and then unwrite within a couple of weeks, has more than doubled, from 3.3 to 7.1 percent. When even the vendors whose business is cleaning up after AI are telling you the mess lands after the typing, believe them.

None of that is a story about typing. It is a story about everything downstream of typing.

Here is what the “10x your engineers” pitch never says out loud: for the work that was actually slow, the keyboard was never the constraint. Writing the code was rarely the slow part. The slow parts were deciding what deserved to exist, reviewing it so it would not hurt you later, and integrating it into a system other people depend on. Those are judgment, and judgment is the part AI barely touched. So when you pour a near-tripling of raw output into a pipeline whose real bottleneck is review and integration, you do not get a near-tripling of software. You get a longer queue.

Any pilot knows the shape of this. A runway launches one aircraft at a time, and regulatory-plus-practical separation sets how soon the next one can follow. That cadence is the constraint. Taxi twice as many planes to the threshold and you do not depart twice as many, because the departure rate is set at the runway: all the extra traffic does is stack up at the hold-short line. Generating code faster without widening review and integration is just more planes on the taxiway. Lines of code was always a vanity metric. All we automated was the dopamine, not the bottleneck.

One cogent pushback is that junior developers genuinely got faster, on the order of a third, while seniors barely moved. That is real. Across a randomized trial of nearly 5,000 developers, the gains concentrated where the work was mechanical, on the juniors whose real constraint was the typing and the boilerplate, and thinned to almost nothing for the seniors, whose bottleneck was judgment on systems they already knew. The lead author’s own read of the senior number: “for those who are more experienced we actually don’t see much of an effect.” The speedup lands where the keyboard was the constraint and vanishes where it never was.

The honest worry is that this is temporary: review and integration are just the next layer to automate. But that is not a worry about the future. It already happened. AI reviewers, test generators, and merge-queue agents have all landed, and the bottleneck did not vanish. It moved up one echelon. So take the limit. Automate every mechanical layer, writing, reviewing, testing, integrating, as far as the tools can reach, and ask what survives. The residual is the work that was never mechanical: deciding what deserves to exist, whether it fits the system, what you choose not to build. That is taste, and distribution, and knowing what the thing is for. Automation does not consume judgment as it climbs the stack. Judgment is what it converges on.

So the leverage was never in generating more. It is in getting faster at the parts that were slow for a reason: deciding, reviewing, shipping. Code was never the scarce thing. Judgment to ship is.

Sources: