A senior engineer at a mid-size company told me she spends more time in review now than she did before her team adopted Claude Code. The team ships more pull requests. She reviews more of them. She feels busier, not faster.
That is not an anecdote about a bad rollout. It is the structural outcome when you solve the generation problem without touching the verification problem.
The generation problem is largely solved
According to Stack Overflow's 2025 Developer Survey, 84% of developers now use or plan to use AI-assisted programming in their workflow. That number matters less than what actually changed: the tools graduated from autocomplete to agents that close full loops. An engineer says "add rate limiting to our API gateway" and an agent analyzes the codebase, identifies the relevant files, implements the changes across multiple modules, writes tests, runs them, and submits a pull request - all autonomously.
The volume follows. OpenAI Codex alone created over 400,000 pull requests in two months.
Only 0.86% of PRs in February 2025 had evidence of being fully AI-authored; by April 2026, that share was 27.6%. Generation is fast, cheap, and getting faster. This is not the problem anymore.
The review problem is barely touched
In GitLab's recent survey, 85% of respondents said the bottleneck has shifted from writing code to reviewing it. The numbers explain why.
LinearB's 2026 benchmarks analyzed more than 8.1 million pull requests across 4,800 engineering teams. At the 75th percentile, AI-assisted PRs were 2.6× larger than unassisted PRs - 408 versus 157 lines of code. Agentic AI PRs also waited 5.3× longer for reviewer pickup: 1,055 versus 201 minutes.
Bigger PRs arriving faster, waiting longer for a human. The math is not favorable.
Daily AI users produce around 4× the raw output of non-users, but measured against their own output a year earlier, the real productivity gain is only about 12%. You're generating roughly four times the code for something like a tenth more delivered value, and a human still has to review all of it.
The quality gap compounds the volume gap. Independent code analyses - notably CodeRabbit's December 2025 report - found roughly 1.7× more issues in AI-coauthored PRs.
In Stack Overflow's 2025 Developer Survey, 66% of developers say they spend more time fixing "almost-right" AI-generated code, and trust in AI accuracy fell to 29%, down from around 40% in prior years.
The review work doesn't distribute evenly, either. Review has shifted toward the most senior engineers, who are scarcer than ever now that AI handles more of the routine coding.
The senior-engineer tax - review time up by triple digits - falls hardest on the people you can least afford to bottleneck, and it is invisible to any metric that only counts merged PRs.
Beagle in action#engineering-standup, 9:02amWhy the optimists aren't wrong, just early
The steelman is real. In a comparison of revert rates across agents and humans over a month in early 2026, two of four agents had lower revert rates than humans. One plausible explanation: developers delegate easy work to agents and keep the hard work for themselves, so the comparison isn't really agent-versus-human on equal tasks.
There's also the habituation effect working in an unexpected direction. Research tracking approval rates over 2025 found that in January 2025, agent PRs were approved less often than human PRs (30.7% vs. 37.8%). Over the following months the trends diverged: agent approval rates rose to 41.7% by July while human approval rates declined - and by June 2025, reviewers approved agent PRs 10 percentage points more readily than human PRs from the same repositories. Reviewers are developing selective trust.
The near-term future of agentic engineering is unlikely to be one giant leap to full autonomy. Most teams adopting agentic coding shift bottlenecks from generation to review, and net velocity gain is close to zero without fixing the loop.
So the optimists are right that agents get better, reviewers calibrate, and the system matures. They're just describing a future state. Right now, most teams are in the transition: they adopted the generation side, skipped the verification side, and are surprised the pipeline slowed down.
What actually needs to change
The teams that are ahead of this have done a few specific things. None of them involve picking a better model.
Treat review capacity as a budget. If an agent can open PRs faster than your reviewers clear them, you have a queue problem, not a generation problem. Measure time-to-first-review separately from time-to-merge.
Size the output, not just the input. Break agent output into small, dependent PRs rather than monolithic changesets. This prevents overwhelming reviewers and enforces developer responsibility for curating changesets into digestible chunks.
Add automated first-pass gates. Some teams are beginning to separate validation from approval and approval from deployment risk. Some are experimenting with merge-first, review-later workflows for changes protected by strong tests and rollback mechanisms; others are reserving human review for exceptions, high-risk areas, and architectural changes.
Log the decision trail. When an agent opens a PR, the reviewer has no implementation journey to follow. When AI generates code, the reviewer often receives a completed diff without the same implementation journey or decision trail. Context has to be attached explicitly, or the review time climbs regardless of quality.
A teammate like Beagle can handle the routing and context-assembly step - surfacing which PRs share a blast radius, who has reviewed similar code before, and what the originating ticket said - so the senior engineer sees a pre-loaded brief, not a cold diff.
Code review did not become less important when agents arrived. It became the central activity. Writing code is increasingly solved and getting cheaper by the month; the durable advantage is the system that lets you trust what was written.
Agentic coding review bottleneck: common questions
Why are AI-generated PRs taking longer to review?
At the 75th percentile, AI-assisted PRs are 2.6× larger than unassisted PRs (408 versus 157 lines of code). Larger diffs take longer to read, have more surface area for subtle defects, and require reviewers to reconstruct intent the agent never documented. Volume compounds the problem: agents can open PRs faster than reviewer queues clear.
Do coding agents actually make teams faster?
On raw output, yes. On delivered value, far less. Daily AI users produce around 4× the raw output of non-users, but the real productivity gain measured against their own prior output is only about 12%. The gap lives in the review queue. Teams that redesign verification alongside generation close more of that gap.
Are agent-written PRs lower quality than human PRs?
The evidence is mixed and context-dependent. Agentic PRs have an 83.8% acceptance rate - lower than human-written PRs at 91%, but not dramatically so. Most rejections stem from project context - duplicate work, submissions made for verification - rather than inherent flaws in AI-generated code. The bigger issue is that accepted agent PRs carry more latent defects on average, and those surface during review or after merge.
What should engineering teams measure differently with agentic coding?
Stop relying on PR count or merge rate as velocity proxies. CircleCI's 2026 report found that for the median team, feature-branch throughput rose 15% while main-branch throughput fell 7%. Track time-to-first-review, reviewer load by seniority, change failure rate, and revert rate separately for agent and human PRs. These tell you whether the delivery system improved, not just whether the generation step got faster.
Is the review bottleneck a temporary problem agents will eventually solve?
Partly. Automated code review agents can triage style, obvious bugs, and policy violations - GitHub reports that Copilot review has now run over 60 million reviews, a 10× increase in under a year, with more than one in five reviews on the platform involving an agent. But architectural judgment, intent reconstruction, and cross-system risk assessment still require a senior human. The bottleneck shrinks; it does not disappear.