Over 88% of developers now use AI regularly, but AI-assisted pull requests merge at less than half the rate of human-authored code. That gap is the thing nobody's talking about when they reach for Claude Code or Cursor. The speed is real. The review queue it creates is also real - and most engineering teams are still running the same PR process they had when a human wrote every line.
That is the actual problem with agentic coding tools in 2026. Not that they don't work. They work. The problem is that your workflow is still shaped around the old bottleneck.
What agentic coding tools actually do now
Agentic coding is not autocomplete with a longer context window. An agent opens a terminal, runs the failing test, reads the stack trace, greps for the broken function, edits the file, re-runs the test, and reports back when green. That is a different category of tool. If 2023 was the year of AI code completion, and 2024-2025 was the rise of AI IDEs, 2026 is the year AI coding enters the agent engineering phase - and the biggest change is not just that models are smarter. You no longer ask AI to finish a line; you delegate issues, tests, migrations, refactors, and cleanup tasks.
An empirical analysis of over 129,000 public GitHub projects found that between 16% and 23% had already integrated agentic coding tools within months of their general availability, spanning projects at all maturity levels, established organizations, and diverse programming languages and domains.
GitHub's Octoverse 2024 report documented that AI-assisted pull requests increased 248% year over year - the highest single-year acceleration in the report's history. That number makes the merge-rate finding even sharper: volume is surging; throughput is not keeping pace.
Why the PR acceptance numbers should change how you work
Here is where the data gets interesting. A peer-reviewed study across five major agentic tools - Codex, Cursor, Claude Code, Devin, and GitHub Copilot - found meaningful variation in how often their PRs actually get merged:
| Agent | PR acceptance rate (aligned 11-week window) |
|---|---|
| OpenAI Codex | 79.9% |
| Cursor | 74.4% |
| Claude Code | 72.6% |
| Devin | 68.0% |
| GitHub Copilot | 68.0% |
Task type dominates: documentation PRs reach 82.1% acceptance and new feature PRs reach 66.1% - a gap larger than most inter-agent differences. In other words, what you assign to the agent matters more than which agent you pick.
And acceptance rate alone flatters the picture. That acceptance rate looks reasonable until you see the detail: 45.1% required human revision for correctness, documentation, or code style. Nearly half of merged agent PRs slipped through with problems a careful reviewer would have caught.
There is also a structural signal buried in the churn data. Agent-introduced symbols - functions and classes - are removed much sooner than those in human PRs: median time to removal is 3 days versus 34 days, with symbol churn at 7.33% vs. 4.10%. Code that gets deleted in three days was probably merged under uncertainty. That is not a model problem. That is a review process problem.
The real bottleneck is not the model; it is your review process
LinearB's 2026 Engineering Benchmarks Report shows AI accelerates code generation but exposes massive bottlenecks in the review process. Most teams have not redesigned the review workflow to match the new rate of code production.
Tasks that required 2-3 days of focused engineering effort are now completed in hours. The ceiling on individual output has risen - which means the bottleneck is no longer writing code.
The steelman for "just adopt agentic tools and trust the process" goes like this: acceptance rates are high enough, agents are getting better fast, and adding friction to the review process will just slow down the gains. That is not wrong. The fraction of agent PRs containing tests grew from 31% in January to 52% by July 2025
- a real sign of maturation. The tools are improving on their own terms.
But the counterargument is that improving test coverage does not fix macro-level communication. Agents generate stronger commit-level messages than humans (semantic similarity 0.72 vs. 0.68) but lag at PR-level summarization (0.86 vs. 0.88). Commit message length is the best predictor of description quality, suggesting reliance on individual commits over full-PR reasoning. This gap between agents' micro-level precision and macro-level communication highlights opportunities to improve agent-driven development workflows.
That is the thing worth paying attention to. The agent can write the function. It often cannot explain, at the PR level, why it made the architectural choice it made. The reviewer has to reconstruct that. When 248% more PRs are landing per year, that reconstruction cost adds up fast.
How to wire your workflow to the new reality
Acceptance rates for agentic PRs are high for maintenance tasks - docs, CI, build - at 74-92%, but lower for complex tasks like features, fixes, and performance work at 35-65%. That asymmetry is the routing decision. Assign agents maintenance and test work by default; treat feature PRs from agents as drafts that need explicit architectural sign-off.
A few concrete adjustments teams are making:
- Separate the review queue. Agent PRs and human PRs get different SLAs. A doc update from Codex does not need the same review depth as a new API endpoint from Claude Code.
- Track agent-specific metrics. Swarmia's coding agents view operationalises this, tracking merge rate, review time per agent PR, batch size, and task success rate as distinct metrics. If you are not tracking these separately, you are averaging signal away.
- Route status to where reviewers already are. When an agent opens a PR at 2am and sits waiting for review, that delay is workflow waste. A teammate like Beagle can surface the PR summary and diff context into the Slack thread where the reviewer is already working - so the review happens in context, not after a tab-switch.
- Weight task type, not just tool. The per-agent acceptance rate spread is 12 percentage points (68-80%). The documentation-vs-feature spread is 16 points. You get more leverage from choosing the right task than from choosing the right tool.
Beagle in action#eng-review, 8:47amJetBrains' Developer Ecosystem Report found that 39% of developers already describe their workflow as "AI-first." That share will keep rising. The teams that benefit most will not be the ones who adopted agents earliest. They will be the ones who redesigned review, routing, and context-sharing to match the new production rate.
The writing of the code is largely solved. The reading of it - at scale, fast, without missing the subtle architectural slips - is where the work is now.
Agentic coding tools: common questions
Do agentic coding tools actually improve engineering productivity?
Yes, with a caveat. GitHub reported Copilot crossed 1.8 million paid subscribers in 2025, with developers completing tasks 55% faster on average. But AI-assisted PRs merge at less than half the rate of human-authored code , so raw output speed does not translate directly to shipped velocity unless the review process is redesigned.
Which coding agent has the best PR acceptance rate?
In a task-aligned study, OpenAI Codex reached the highest acceptance rate at 79.9%, followed by Cursor at 74.4%, Claude Code at 72.6%, and Devin and GitHub Copilot both at 68.0%. The spread matters less than task type: docs and CI work clears at 82%+; new features at roughly 66%.
What is the difference between vibe coding and agentic coding?
Simon Willison frames the practice as professional engineers using coding agents to amplify existing expertise, not replace human judgment with vibes. Vibe coding works when the cost of being wrong is zero. Agentic coding has to work when the cost of being wrong is a customer outage. The tools overlap; the attitude toward correctness does not.
Why do agent-written PRs get deleted so quickly after merging?
Agent-introduced symbols are removed with median time to removal of 3 days versus 34 days for human-written code, with symbol churn at 7.33% vs. 4.10%. This reflects merges made under uncertainty - reviewers approved code they were not fully confident in. It is a review-process failure, not solely a model-quality failure.
How should teams assign work to coding agents?
Start with task type, not model choice. Agentic PRs on maintenance tasks - docs, CI, build - accept at 74-92%; on features, fixes, and performance work the range drops to 35-65%. Assign agents the high-acceptance categories first, measure your actual merge and revision rates by task type, and expand scope only where the data supports it.