Harvard & Jellyfish Study of 718 Firms Finds AI Coding Gains Stall in Pull Request Reviews

A massive empirical study conducted by Harvard researchers using the Jellyfish engineering analytics platform has put hard numbers behind a frustration that software teams across the industry have felt all year: while autonomous AI coding agents dramatically increase the amount of code developers write, most of that speed gain evaporates inside the pull request (PR) review queue.

Analyzing approximately 300 million work events across 700,000 workers at 718 companies between January 2021 and March 2026—spanning Git repositories, Jira issue trackers, Google Calendar schedules, and AI tools including GitHub Copilot, Cursor, and Claude Code—the researchers compared raw code generation against actual completed business work (measured by resolved Jira issues and epics per engineer per month).

The data shows a striking split between standard autocomplete assistants and autonomous coding agents. Traditional AI coding assistants produced modest code volume bumps (+12% lines of code, +9% commits, +5% pull requests) and zero statistically significant increase in resolved Jira issues. Autonomous AI coding agents drove much larger surges in raw code output—lifting lines of code by 30%, commits by 20%, and pull requests by 23%—yet translated into only a 12% increase in resolved Jira issues.

When the Harvard team traced where the missing productivity went, they found a classic downstream bottleneck: engineers only spend 30% to 40% of their workweek writing code, and flooding the pipeline with AI-authored pull requests overwhelmed human reviewers. Across the 718 firms, average PR review time jumped by 49%, review comments per PR rose by 53%, and the share of PRs requiring rework doubled—even when controlling for PR size.

Fast Facts: Harvard & Jellyfish Study of AI Coding Across 718 Companies

• Dataset Scale & Window: Approximately 300 million work events from 700,000 engineers across 718 firms (January 2021–March 2026), validated with time-use surveys of 100 engineers, as reported by InfoQ.
• AI Autocomplete Assistants vs. AI Agents (Code Output):
• AI Assistants: +12% lines of code, +9% commits (statistically significant), +5% pull requests, and 0% gain in resolved Jira issues.
• AI Coding Agents: +30% lines of code, +20% commits, +23% pull requests, and a +12% gain in resolved Jira issues/epics.
• The 30%–40% Coding Time Reality: Engineers spend only 30% to 40% of their time writing code; the other 60% to 70% goes to scope planning, code review, testing, and deployment.
• The Pull Request Bottleneck Surge:
• Average PR Time to Review: Increased by +49%.
• Review Comments per PR: Increased by +53%.
• Share of PRs Requiring Changes: Doubled (2x).
• Engineers Pulled into Reviewing: Share of staff performing code reviews rose +14%.
• AI Review Tools Didn’t Clear the Jam: Adopting AI code-review bots showed no measurable reduction in human PR review time across the dataset.

Empirical Comparison: AI Code Generation Gains vs. Downstream Review Costs

The table below summarizes how AI assistants and autonomous agents affected each stage of the software delivery lifecycle across the 718 studied enterprises.

Why AI-Generated Code Takes 49% Longer for Humans to Review

Notice a crucial finding in the Harvard and Jellyfish paper: the 49% jump in PR review time and the doubling of PRs requiring changes could not be explained simply by larger pull requests. Even when an AI agent submits a moderately sized PR, reviewing someone else’s machine-generated code is cognitively harder than reviewing human code for three practical reasons:

1. Plausible-Looking Subtle Bugs: When a human junior developer makes a mistake, the syntax or structure usually looks obviously rough. An AI coding agent writes polished,idiomatic code that compiles and passes happy-path tests while hiding subtle concurrency bugs, hallucinated edge-case assumptions, or redundant abstractions.
2. Author Comprehension Decay: When an engineer uses Claude Code or Cursor to generate a 400-line feature in ten minutes, the author themselves often has a shallower mental model of the code they just submitted—leading to longer back-and-forth comment threads (+53% comments) when a senior reviewer asks why a state transition was written a certain way.
3. Why AI Code-Review Bots Failed to Help: Many teams tried to fight fire with fire by turning on automated AI PR review bots. In the Jellyfish dataset, those bots generated even more comments to read without relieving the human sign-off burden.

Practical Playbook: How Engineering Leaders Can Unblock the PR Review Queue

If your team uses Cursor, Claude Code, or Copilot Agents, you will not get the full productivity dividend by telling developers to write code faster. You have to redesign how code is scoped and reviewed:

1. Shift AI Agents Upstream to Specs & Test Suites Before Implementation: Since engineers spend 60%–70% of their time outside raw coding, require developers to review a short 1-page architectural plan and edge-case test list before the agent writes a single line of implementation code—cutting the 2x PR rework rate at the root.
2. Enforce “Author Must Self-Review & Annotate” Rules on Agent PRs: Ban “generate-and-throw-over-the-wall” pull requests. Require the PR author to leave inline explanatory comments on complex blocks and attach deterministic test evidence before requesting a human reviewer.
3. Cap PR Diff Size at 250 Lines for Agent-Assisted Branches: Because AI agents make it effortless to touch 15 files at once, enforce automated CI checks that flag oversized diffs and force agents to ship stacked, single-purpose pull requests that a human can verify in under 10 minutes.
4. Track Resolved Issues and Mean Time to Recovery (MTTR), Never Lines of Code: Stop rewarding or measuring AI adoption by LOC or PR counts; track completed customer-facing issues, PR cycle time, and post-merge defect rates.