Back to Blog
ResearchMarch 29, 2026 · 7 min read

Developers Are Opening 98% More PRs With AI. Their Reviews Got 91% Longer.

CodeRabbit reviewed 13M PRs: AI-coauthored PRs have 1.7x more issues. Incidents per PR up 23.5% YoY. PR size up 154%. The review bottleneck data nobody's talking about.

Published by GitIntel Research

TLDR

The 154% PR size increase is particularly brutal. Larger diffs require more cognitive load to review. Reviewers spend more time per PR. Meanwhile, the queue keeps growing. This is the review debt spiral.

AI-Coauthored Code Has More Issues. The Data Is Clear.

CodeRabbit — the AI code review tool now connected to 2 million repositories and having reviewed 13 million pull requests — released a benchmark in December 2025. The headline finding: AI-coauthored PRs generate approximately 1.7× more review issues than human-only PRs (10.83 vs. 6.45 findings per PR on average).

This isn't a knock on AI code quality. It reflects a different kind of code. AI-generated code tends to be more verbose, more complete in scope, and more likely to touch adjacent systems. More lines, more surface area, more findings.

CodeRabbit Benchmark, December 2025

Source: 2M connected repos, 13M PRs reviewed

Review findings per PR: Human-only PRs: 6.45 issues/PR AI-coauthored PRs: 10.83 issues/PR Ratio: 1.68×

Top issue categories in AI PRs: Logic gaps: 34% Missing error handling: 22% Test coverage holes: 19% Style/naming: 15% Security concerns: 10%

The Cortex 2026 Engineering Benchmark adds another angle: incidents per pull request increased 23.5% year-over-year, even as teams deployed more automation and process controls. More automation, more incidents per merge. The pipeline is moving faster than the quality gates.

AI Code Review: The Fastest-Growing Developer Tool Category

Stack Overflow's annual developer survey has tracked AI-assisted code review for three years. The trajectory is steep:

% of professional developers using AI-assisted code review

{adoptionData.map((row) => (

{row.year}

{row.pct}%

{row.label}

))}

That's a 4.3× increase in three years. GitHub Octoverse 2025 measured the footprint: 1.3 million repositories are now using AI code review tooling — up 4× from roughly 300,000 in late 2024.

The upside is real. Repos using AI review show 32% faster merge times and 28% fewer post-merge defects (GitHub Octoverse 2025). The tools work. The problem is adoption outpacing governance: most teams are using AI review without defining what level of confidence warrants auto-merge, or what issue categories block a PR vs. flag it for human review.

The Governance Gap: Nobody's Defined the Trust Threshold

In a survey of 2,000+ engineering teams, 66% of developers cited "almost correct" AI-generated solutions as their biggest frustration — code that looks right, passes linting, and fails in production.

This is the governance gap. Teams have deployed AI code review tools but haven't defined:

The Practical Gap

JPMorgan Chase deployed AI coding tools to 60,000+ developers and measured a 30% improvement in developer velocity. But none of the public case studies specify their merge approval policy for AI-reviewed code. The infrastructure exists. The governance layer doesn't.

What the Numbers Actually Mean

For engineering managers

Your AI tools are creating a hidden backlog. If your team is opening 98% more PRs but your review capacity hasn't scaled, you have a growing queue of unreviewed work. Incidents per PR being up 23.5% YoY means each of those PRs carries more production risk than it did last year.

For platform teams

The missing layer is a trust scoring system — one that factors in AI authorship percentage, issue category severity, reviewer identity, and historical incident correlation. 47% of developers are already using AI review tools. The question is whether those tools feed into your merge policy or are just advisory noise.

For developers

Amazon Q Developer measured a 27% reduction in deployment rollbacks from configuration errors when AI review was in the loop. The tools add genuine signal. The problem isn't using them — it's that AI review catches different things than human review, and teams haven't calibrated expectations accordingly.

Where GitIntel Fits

AI code review tools like CodeRabbit analyze the code in the PR. That's valuable. But there's a prior question most teams aren't asking: how much of this PR was AI-generated in the first place?

If a PR is 85% AI-authored — as some Deno commits are — the review bar should be different than a 10% AI-assisted PR. Attribution context changes how reviewers allocate attention. It changes what your AI review tool should weight. It affects your compliance posture if your organization has AI code policies.

GitIntel measures that. It reads git history — commit trailers, co-author metadata, agent signatures — and tells you what fraction of any file, directory, or PR was AI-generated. That number feeds everything downstream: review policy, risk scoring, audit trails.

$ gitintel scan --format json --limit 100

{ "total_commits": 100, "ai_commits": 41, "ai_percentage": 41.0, "agents": { "claude-code": 40, "devin": 1 }, "lines_added_by_ai": 24831, "lines_added_total": 38944, "ai_line_percentage": 63.8 }

The review crisis is partly a visibility crisis. Teams don't know how much of what they're reviewing was AI-generated, which tool generated it, or whether the attribution data even exists. GitIntel makes that visible so the governance layer can be built on top of it.

Know Your AI Exposure Before It Hits Review

Run gitintel scan on any repo to see AI attribution data before your next PR cycle.

# Install
curl -fsSL https://gitintel.com/install.sh | sh

# Scan current repo
cd your-repo
gitintel scan

View on GitHub

Open source (MIT) · Local-first · No data leaves your machine

Sources: McKinsey Technology Report February 2026; DX Developer Coefficient Study (135K developers); Faros AI Productivity Paradox Research 2026; CodeRabbit Benchmark December 2025; Cortex Engineering Benchmark 2026; Stack Overflow Developer Survey 2023–2025; GitHub Octoverse 2025.

Related reading on GitIntel: