LinearB published its mid-year AI benchmarks this week. The dataset covers 8.1 million pull requests across 4,800 engineering teams in 42 countries. The headline number isn't the one they lead with.

It's this: AI-assisted PRs merge at 32.7%. Manual, human-written PRs merge at 84.5%.

Less than half the rate. On more than twice the volume.

That's a significant gap. And it has a specific shape — because the obvious interpretation is probably wrong about what's causing it.

Source spread

• LinearB — 8 million pull requests reveal where engineering productivity breaks down — builder. Primary source; LinearB's own mid-year analysis of the H1 2026 dataset.
• Dev Interrupted — Why AI-assisted PRs merge at half the rate of human code — builder. LinearB's podcast covering the benchmarks with methodology context.
• Devinterrupted Substack — Why AI-assisted PRs merge at half the rate — skeptic. Covers the productivity paradox and raises whether AI tools are generating speculative work that teams never intended to ship.
• Linear — AI usage patterns in software teams — builder. Linear's own data on AI-written issue authorship, approaching half of all issue creation.

Pros & cons

What the data actually shows:

• 88.3% of developers now use AI regularly, up from just under 72% in early 2024. Adoption happened fast.
• Teams with high AI adoption shipped 98% more PRs. That number is real. AI made individual developers dramatically more productive at generating code.
• AI now writes just under half of all Linear issues — not just code, but task definition, spec writing, issue creation. The tools are further into the workflow than most engineering managers' mental models.
• The overall dataset is big enough to trust. 8.1 million PRs isn't a survey; it's measurement.

What isn't working:

• Review time rose 91% for high-AI teams. More PRs, each waiting longer. The bottleneck moved from "time to write the code" to "time to review and merge it."
• AI PRs wait 2.5 to 5.3 times longer for review than human-written PRs. Reviewers are uncertain, skeptical, or both.
• The net org productivity gain averages around 10%. Which isn't bad — but when 88% of developers are using AI and teams are shipping 98% more PRs, a 10% org-level gain implies a serious efficiency leak somewhere in the pipeline.

What builders need to know

• Review queue is the bottleneck now, not code generation. If your team's AI adoption is high and shipping pace hasn't improved, look at PR cycle time and review wait time. Not code-generation speed.
• Separate your merge-rate metrics by PR source. If you're not tracking AI-assisted PRs separately from human-written PRs in your engineering metrics, you're averaging over a bimodal distribution and losing the signal.
• Better specs going into AI → better PRs coming out. The data suggests well-specified tasks produce AI code that reviews much closer to human rates. "Implement the auth refactor we discussed" → bad. "Write a function that takes a JWT and returns the user ID or throws a specific error type if the signature is invalid" → better.
• The issue backlog is getting inflated too. AI writes just under half of all Linear issues now. If those issues aren't well-scoped, the merge-rate problem downstream in the PR queue has a root cause upstream in how work is being defined.
• 10% org productivity gain on 88% AI adoption is recoverable. But you need to fix how work gets defined, not how it gets written. The writing part is already working.

Further reading

• LinearB — 8 million pull requests reveal where engineering productivity breaks down — primary benchmark data and analysis
• Dev Interrupted — Why AI-assisted PRs merge at half the rate of human code — methodology context and team-level breakdown
• Devinterrupted Substack — Why AI-assisted PRs merge at half the rate — long-form analysis on the speculative work hypothesis
• Linear — AI usage patterns in software teams — issue authorship data, AI vs human