AI Made Writing Code Nearly Free. Reviewing It Got 91 Percent Slower.
Two and a half years of AI coding, as told by the industry’s own numbers, biases included
AI Made Writing Code Nearly Free. Reviewing It Got 91 Percent Slower.
Two and a half years of AI coding, as told by the industry’s own numbers, biases included
Arlington, Virginia
LinearB analyzed 8.1 million pull requests across 4,800 organizations for its 2026 benchmarks and found that developers using AI feel 20 percent faster and are measurably 19 percent slower. A 39-point gap between the speed people report and the speed the telemetry records, held by an industry that measures nearly everything.
One caveat belongs up front, before any of the numbers. Nearly every figure in this piece comes from the AI industry measuring itself: tool vendors benchmarking their own market (LinearB sells engineering metrics, Sonar sells code quality, Lightrun sells debugging), a model lab reporting on its own agents (Anthropic), and surveys run by companies with products to place against the findings. The vendors profit from the problem being real. They have every incentive to size the review crisis generously, and they also had the telemetry to catch it first. Each number below carries its source inline. The independent anchors are Stack Overflow’s developer survey and GitClear’s repository analysis, and their picture points the same direction as the vendors’.
The gap itself took two and a half years to build, and at every step the actors did something locally sensible while the queues did the rest.
A Brief History of Trust in Computing
2024: the demos
Devin launched in March 2024 as an autonomous software engineer and, per its maker Cognition, resolved about 14 percent of real-world GitHub issues, which sounds modest until you notice that the number for every previous tool was zero at that level of autonomy. Money noticed. AI venture funding passed $100 billion for the year, up more than 80 percent over 2023, and in December Google announced Gemini 2.0 with a phrase attached: the agentic era, which the industry adopted before the era had agents in production.
Telemetry from that year told a quieter story. Developer trust in AI output stood at 40 percent (Stack Overflow’s annual survey), and GitClear’s analysis of 211 million lines of code found churn had climbed from 3.1 percent in 2020 to 5.7 percent in 2024, with code duplication up roughly four times and refactoring down from a quarter of all changes to under a tenth. Generation was accelerating while the codebases receiving it grew messier by the same measures.
2025: the deployment
The plumbing arrived first. In March 2025, OpenAI adopted Anthropic’s Model Context Protocol across its products, which settled MCP as the standard for connecting agents to tools, and rival labs adopting each other’s protocols is roughly as common as rival railroads agreeing on a gauge. In May, Anthropic shipped Claude Code and the agents moved into the terminal. OpenAI’s rebuilt Codex followed in mid-year as a cloud agent running multi-hour tasks in sandboxes. By year’s end the vendors had converged on one architecture, agents that read repositories, run tests, and iterate on failures, wearing different logos.
Adoption and trust then moved in opposite directions at once. Stack Overflow’s 2025 survey of more than 49,000 developers found 84 percent using or planning to use AI coding tools, while trust in the output fell to 29 percent, down from 40 the year before. Read together: the industry roughly doubled its commitment to tools it trusted almost half as much. The agent half of the story also stayed smaller than the noise suggested, with 52 percent of developers not using agents or sticking to simpler tools, and 38 percent reporting no plans to adopt them at all.
2026: the queues
Then the constraint moved from writing to review, and the survey data caught it happening.
Digital Applied’s first-quarter survey of 2,847 developers recorded the crossover: reviewing generated code overtook writing code as the largest AI-assisted time sink, after writing had held a four-hour lead as recently as 2024. LinearB’s benchmarks put the mechanics under it. Developers using AI complete 21 percent more tasks and merge 98 percent more pull requests, review time is up 91 percent, and a pull request opened by an agent waits 5.3 times longer for a reviewer to even pick it up. CircleCI’s data completes the picture from the pipeline side: feature branch throughput rose 59 percent year over year while main branch throughput for the median team fell. More work entered the system and less came out the far end. Viewed from above, a saturated constraint looks exactly like that.
Quality numbers explain the hesitation at the review desk. Sonar’s survey of 1,100 developers, run by a code-quality vendor, found AI writing 42 percent of committed code, while 96 percent of developers said they do not fully trust it to be functionally correct and only 48 percent reported always verifying it before committing. Lightrun, a debugging vendor, found 43 percent of AI-generated changes requiring manual debugging in production after passing QA and staging, and zero percent of surveyed engineering leaders described themselves as very confident that AI code will behave correctly once deployed. Zero is a rare number in survey research. It takes real consensus.
The distrust has a precedent, and it lost. When John Backus’s team built the first FORTRAN compiler in the 1950s, working programmers doubted a machine could generate code they would trust. Backus later described the field as a priesthood, guarding hand-tuned assembly as a craft no automated translator could match, and he built the compiler under that exact pressure: his own account of the project states the team’s belief that if FORTRAN produced object code even half as fast as hand-coded assembly during its first months, the system’s acceptance would be in serious danger. The compiler shipped in 1957 close enough to hand-coded speed that the skepticism collapsed within a few years, and by 1958 more than half the code running on IBM computers had been generated by it rather than written by hand. Nobody asks a compiler to prove itself before every build anymore. The distrust of AI-generated code sits at the point FORTRAN sat at in 1956, before the record was in.
Capability kept climbing through all of it. Devin’s issue-resolution rate reached roughly 50 percent, up from 14 at launch. Anthropic’s own trends report, a lab reporting on its own agents, described one at Rakuten implementing a feature across a 12.5-million-line codebase in a seven-hour autonomous run. Cursor passed $2 billion in annual recurring revenue by February with half the Fortune 500 aboard. And in a development that says more than any benchmark, US insurers spent early 2026 rewriting general liability policies to exclude AI agent losses by default. The actuaries finished their risk assessment before most org charts started theirs.
One more number from the same Anthropic report, with the same caveat attached: about 27 percent of AI-assisted work did not previously exist. The capacity arrived and the backlog grew to absorb it.
The laws were already written
Nothing in the timeline required a new theory. It ran on old ones.
The constraint moved, which Goldratt described in 1984: break one bottleneck and another takes its place. Writing was the constraint, so the industry spent billions breaking it, and the constraint reappeared at review, where agent pull requests now age 5.3 times longer in the queue. The next appearance is already visible, since over 90 percent of teams ship in batches and changes are piling up past review in deployment queues. Speeding up review will move the constraint again rather than remove it.
The backlog expansion is Gustafson’s law from 1988: given more capacity, people grow the workload to fit it rather than finishing the old workload faster. The 27 percent of work that did not previously exist is that growth, measured. Agent capacity is being spent the way headcount always was, on more scope at similar speed.
And the 39-point perception gap belongs to measurement. A developer feels generation, since the typing got faster and the completed tasks climbed, while the organization gets delivery, which runs through the queue. Teams watching generation metrics feel the 20 percent, teams watching cycle time see the 19, and both readings are honest. They measure different stages of the same pipeline, on opposite sides of the constraint.
What a manager budgets differently
The organizations pulling ahead treat review capacity the way they already treat CI: as capacity to plan explicitly rather than a queue expected to manage itself. Every mandate to double engineering output carries an unstated assumption about review capacity that was never budgeted, and the LinearB numbers show the missing budget’s cost.
The rest follows from the same accounting. Pull request size limits hold regardless of how cheap generation gets, because an agent can produce a massive diff in minutes and a reviewer still cannot absorb one. Machine-checkable acceptance criteria and automated first-pass review move the baseline checks off human eyes, reserving people for intent and architectural fit. Verification skill, the ability to evaluate what an agent produced, is becoming a core engineering competency and belongs in hiring criteria and promotion rubrics now, ahead of the backlog it will clear. The reporting layer needs its own correction: measure delivery, not generation, or the dashboard will keep telling the 20-percent story while customers live the 19.
One structural change rounds out the period. The Pragmatic Engineer’s 2026 survey of more than 900 engineers and leaders found the roles converging: engineers orchestrate agents and context-switch across parallel runs, managers are more hands-on technically than they have been in a decade, and the survey’s authors drew the conclusion themselves that the engineer and manager jobs are growing similar. The org chart has not caught up with that yet. Neither have most career ladders.
Two and a half years, one repeating sequence, reported almost entirely by parties with something to sell, and consistent anyway. Capability climbed above the line while the bill accumulated below it, and the bill came due at whichever stage nobody had budgeted. The next capability milestone is certain. So is the next queue, and the managers who come out ahead will be the ones who budget for the queue before the milestone ships it full.
By Joshua McDonald on August 13, 2026.
Exported from Medium on August 26, 2026.
Reader discussion