AI Writes Half Your Code Now. So Why Are Your Pull Requests Slower?
Generation became cheap. Verification didn’t. The bottleneck just moved — and the data says most teams haven’t noticed where.
For the skim reader
- AI now writes ~half of all code: 51.9% of output in DX’s Q2 2026 data; Sonar’s survey puts committed AI code at 42%, heading to 65% by 2027.
- Review is the new bottleneck: median PR size nearly doubled in a year, and review time is up sharply — one 2026 analysis measured +91%.
- The perception gap: developers feel 20% faster with AI. Delivery data across 8.1M pull requests says they’re 19% slower.
- Human review is quietly disappearing: a peer-reviewed 2026 study found 61% of AI-agent pull requests receive no review at all.
- What to do: three metrics to pull from your own Bitbucket this week, and ground rules for AI-authored PRs.
Every engineering leader heard the same promise in the last two years: AI writes the code, your team ships faster. The first half came true. In DX’s preliminary Q2 2026 data, AI-authored code reached 51.9% of output across participating organizations, with the median holding at 50%. Sonar’s 2026 State of Code survey of 1,100+ developers is more conservative — 42% of committed code — but projects 65% by 2027.
The second half of the promise is where it gets interesting. Because for a lot of teams, shipping didn’t get faster. It got slower.
The numbers nobody reconciles
Individually, developers using AI daily do move more: they merge 2.3 pull requests per week versus 1.4 for non-users. But between July 2025 and June 2026, the median PR size nearly doubled — from 44 lines to 72. More PRs, bigger PRs, the same number of reviewers. Something has to give, and it did: review queues.
The most uncomfortable number comes from LinearB’s analysis of 8.1 million pull requests across 4,800+ organizations: developers using AI feel about 20% faster — and are actually about 19% slower end-to-end. That’s a 39-point gap between perceived and measured productivity. The generation step accelerated so visibly that nobody looked at what happened downstream.
Why review broke
Code review was calibrated for a world where the author understood their own code. The reviewer was a second pair of eyes: skim the approach, poke at the risky parts, approve. AI-authored code breaks that contract. The “author” often can’t explain every line of their own PR — so the full burden of understanding the change lands on the reviewer, who now reads line by line instead of skimming.
And reviewers have reasons not to skim. In the same 2026 survey data: 96% of developers don’t fully trust AI-generated code for functional correctness, yet only 48% say they always verify it before committing. Lightrun’s 2026 report found 43% of AI-generated changes required manual debugging after they reached production. Security scans show AI-generated code carrying roughly 2.7× more vulnerabilities than human-written code. AI code looks plausible — its defects are subtle, which is exactly the kind of code that takes longest to review honestly.
Cheap generation, expensive verification: the bottleneck didn’t disappear, it moved one step to the right. The Pragmatic Engineer’s 2026 survey captured teams facing 30 PRs a day with six reviewers — in their words, “unsustainable no matter how you look at it.”
Meanwhile, human review is quietly disappearing
Here’s the finding that should worry admins more than slow queues. A 2026 study accepted at EASE (based on the AIDev dataset of 930k+ pull requests from GitHub repositories with 100+ stars) looked at what actually happens to PRs opened by AI coding agents:
And of the AI-agent PRs that were reviewed, only about 10% were reviewed exclusively by humans — the majority were reviewed by other AI agents. Human involvement increasingly takes the form of steering commands to the agent (“fix the lint failure”, “rebase”) rather than actual evaluation of the code. Review didn’t just slow down. For a growing share of code, it silently stopped being human.
The market’s answer: AI reviewing AI
The vendor response to an AI-created bottleneck is, predictably, more AI. Atlassian’s entry is Rovo Dev code review, which joins pull requests in Bitbucket Cloud and GitHub as a reviewer: inline comments on logic errors, security issues and anti-patterns, plus one genuinely differentiated trick — it checks the PR against the acceptance criteria of the linked Jira work item, not just the diff.
Two things make it worth a look even if you’re skeptical of AI review. First, the architecture is built around noise reduction — the top complaint about AI reviewers. One model generates comments, a second model acts as a judge to filter hallucinated or inaccurate ones, and a third scores whether a comment is likely to be actionable. Second, Atlassian published measured results in a peer-reviewed study (accepted at ICSE 2026): a year-long evaluation across 1,900+ of their own repositories showed median PR cycle time dropping 30.8%.
The honest caveat is in their own data: 38.7% of the AI reviewer’s comments led to code changes, versus 44.45% for human reviewer comments. The machine is still noisier than a person. Which is why the sane deployment pattern isn’t “replace the reviewer” — it’s the review sandwich: let the AI catch the surface issues first (typos, anti-patterns, obvious security misses), and spend the human’s attention on architecture, business logic, and the question the AI can’t answer: should this change exist at all?
What to measure in your own instance this week
You don’t need a survey to know if this is happening to you. Three numbers, all pullable from Bitbucket (or any git platform) in an afternoon:
| Metric | What it tells you | Warning sign |
|---|---|---|
| Median time to first review | Whether your review queue is absorbing the extra PR volume | Trending up over the last 2–3 quarters |
| Median PR size (lines changed) | Whether AI generation is inflating change size | Doubling year-over-year, like the industry’s 44→72 |
| % of PRs merged with zero human comments | Your own version of the 61% number — how much code ships without human eyes | Anything you wouldn’t say out loud in an audit |
Then three ground rules that cost nothing to adopt:
- Label AI-authored PRs. A PR template checkbox or label. You can’t manage the ratio you can’t see — and your future compliance team will thank you.
- Keep PR size limits, especially now. Generation speed is not a reason to review 800-line changes. Big AI PRs are precisely the ones hiding subtle defects.
- “The author must understand every line.” The one rule that repairs the broken contract. If the person opening the PR can’t explain it, it isn’t ready for review — no matter who or what wrote it.
The bottom line
AI didn’t remove your bottleneck — it moved it from writing code to trusting code. Teams that treat verification as the real product of engineering (review capacity, review rules, review metrics) get the AI speedup. Teams that only count generated lines get a 39-point gap between how fast they feel and how fast they are — and a growing pile of code no human has ever read.
We’re living the same lesson — with diagrams
We’re finishing AI generation and editing for Diagram.now for Confluence. It taught us exactly what the data above says about code: generating a diagram from a prompt is the easy part. Making the result trustworthy — and instantly editable when the AI gets it 90% right — is the actual product. Announcement soon.
Meet Diagram.now for ConfluenceSources: DX preliminary Q2 2026 AI-assisted engineering data; Sonar 2026 State of Code Developer Survey; LinearB analysis of 8.1M pull requests (4,800+ organizations); Lightrun 2026 report; Duma et al., “These Aren’t the Reviews You’re Looking For: How Humans Review AI-Generated Pull Requests,” EASE 2026 (arXiv:2605.02273); Atlassian, “30.8% Faster PRs” engineering blog and accompanying ICSE 2026 paper. Figures are as reported by their respective sources in mid-2026; Rovo Dev code review availability: Bitbucket Cloud and GitHub.