The Bottleneck Moved
For twenty years, writing code was the slowest part of the software delivery pipeline. Requirements, architecture, and review all had enough slack to keep up. AI coding tools changed that almost overnight.
LinearB's 2026 Software Engineering Benchmarks Report — analyzing 8.1 million pull requests from 4,800 teams across 42 countries — reveals the downstream consequence: developers using AI complete 21% more tasks and merge 98% more PRs, but PR review time has increased by 91%.
The bottleneck didn't disappear. It shifted from code creation to code verification.
The Numbers Tell the Story
AI-generated PRs wait 4.6x longer before a reviewer picks them up, even though they're reviewed 2x faster once someone starts reading. The acceptance rate for AI PRs sits at just 32.7%, compared to significantly higher rates for human-authored work. Teams are generating 200+ pull requests per week with the same review capacity they had when they were generating 80.
Meanwhile, 96% of developers say they don't fully trust AI-generated code, so rubber-stamping isn't an option. Every AI-authored diff needs genuine human verification.
The Hidden Cost: Context Collapse
Slow reviews create a compounding problem that goes beyond cycle time. When a PR sits unreviewed, the author has to hold that context in their head while starting new work. Two open PRs become three. Rebases pile up. By the time feedback arrives, the codebase has shifted underneath the original change, and what was a clean diff now requires rework.
This is what some are calling the AI productivity paradox: developers feel 20% faster but are actually 19% slower when you measure end-to-end delivery. That's a 39-point perception gap.
What Actually Helps
The teams navigating this well aren't just throwing more reviewers at the queue. They're:
- Keeping PRs small — even when AI makes it easy to generate large changesets
- Triaging by risk — not every PR needs the same depth of review. Automated risk scoring can flag which changes touch sensitive files, have merge conflicts, or carry high diff complexity
- Using AI for first-pass review — letting AI catch the obvious issues (style, bugs, security flags) so human reviewers can focus on architecture and business logic
- Centralizing visibility — when PRs are scattered across dozens of repos on GitHub and GitLab, stale reviews go unnoticed. Tools like Code Board aggregate PRs into a single Kanban view with risk scores, making it harder for things to fall through the cracks
The Real Takeaway
The tooling and processes most teams rely on were designed for a world where writing code was the constraint. That world is gone. If your review process hasn't changed but your code output has doubled, you haven't become faster — you've just moved the queue.
Adjusting to the new bottleneck isn't optional. It's the difference between teams that actually ship faster and teams that just write faster.
