# Thirty-Six Percent More Pull Requests, Fifty-Six Percent Longer to Merge

> Source: <https://gautamparab.com/writing/fifty-six-percent-longer-to-merge/>
> Published: 2026-11-19 18:40:13+00:00

**Recommendation:** Plan review capacity alongside agent rollout: the study measured pull requests opened up 35.7 percent but merged up only 26.0 percent and merge time up 56.1 percent, so staff reviewers and triage before scaling agent output.
More in the playbook "Running AI in production": <https://wpnews.pro/playbooks/production-ops>

Fiona Chen and James Stratton, two Harvard PhD candidates, have a job-market paper called *Artificial Intelligence in the Firm: Bottlenecks in Software Production*. It was first circulated in January, and the version on Chen’s site is dated 14 November. It reached Hacker News this week through a write-up that quoted an August draft. That draft had lines of code up about 30 percent and time to merge up 49 percent. The current version has different numbers, from a slightly different sample. I’m using the current version throughout.

The data comes from Jellyfish, an engineering analytics platform. It covers 720,542 workers at 655 firms from January 2021 to August 2026: 297.6 million commits, 54.1 million pull requests and 73.1 million Jira issues. The design is a staggered difference-in-differences. Firms that adopted coding agents earlier are compared with firms that hadn’t adopted yet, and the paper argues the timing gap mostly comes from how long procurement took. One detail matters for reading every agent number below: the agent effect is measured on top of earlier adoption of coding assistants such as Copilot. It’s the extra effect of agents, not the effect of AI starting from zero.

The headline is in the title. Code went up, finished software went up much less, and the place the difference shows up is review.

## The chain from code to shipped work

Here is what happened twelve months after a firm adopted agents, as a share of the pre-adoption mean, moving down the production chain.

Pull requests opened rose 35.7 percent, from a baseline of 4.83 per worker-month. Pull requests merged rose 26.0 percent. Resolved Jira issues, which the paper counts when the associated code is deployed, rose 13.7 percent. That last estimate isn’t significant, and the upper end of its confidence interval is 30.7 percent. So even at its most generous, the data rules out shipped tasks keeping pace with pull requests.

The paper checks whether issues just got bigger, using models to predict how long each issue would take from its text. It finds no change in average predicted length. It also checks whether pull requests got bigger and finds no significant change in lines added per pull request. So the drop isn’t units being redefined. Something between “opened” and “shipped” is absorbing work.

## Where the extra pull requests went

The merge rate shows it most directly. Before agents, 86.1 percent of pull requests opened at these firms were merged. After agents, firms opened 1.73 more pull requests per worker-month and merged 1.08 more.

The paper puts the merged share of the added pull requests at 62.7 percent. The other third was either closed or still waiting, and the review clock says a lot of it was waiting.

## The review clock

The paper’s main review measure is days from pull request submission to merge. A year after agent adoption it rose by 1.99 days on a baseline of 3.56, or 56.1 percent. For pull requests that got at least one comment, the paper splits that time in two. Backlog runs from submission to the first comment from someone other than the author. Active review runs from that first comment to the merge.

The split is useful because it separates two explanations. If reviewers were just busier, the backlog would grow. If agent-written code needed more work per pull request, active review would grow. Both grew, by 59.9 and 58.5 percent. Comments per pull request rose 38.6 percent, from 1.63. Formal change requests rose 38.5 percent from a low base of 2.77 percent of pull requests, though that estimate is marginally insignificant.

Combine the clock with the arrival rate and you get a number the paper doesn’t print. Little’s law says the average number of items in a system equals the arrival rate times the average time each item spends there. It holds for any stable queue, whatever the arrival pattern. If pull requests arrive 1.357 times as fast and spend 1.561 times as long between submission and merge, the stock of pull requests sitting in review is about 1.357 × 1.561 ≈ 2.1 times what it was. That’s a rough figure. The time is measured on merged pull requests, a firm a year after adoption may not be in steady state, and a mean over firms isn’t a queue. Still, the direction is clear: per engineer, about twice as much unmerged code is sitting open at any moment.

Queueing theory also explains why the wait can grow faster than the load. In his 1961 paper on the single-server queue, J. F. C. Kingman wrote that when traffic intensity nears one, “the queue will be long and the queueing time large.” The approximation that bears his name has mean waiting time growing like 1/(1−ρ), where ρ is the share of time the server is busy. A reviewer who is busy half the time and gets a third more work goes to two-thirds busy, and on that approximation their mean wait rises by half, not by a third. A reviewer at 80 percent can’t absorb that extra third at all. This is why I don’t find the 56.1 percent surprising. If review capacity stayed roughly fixed while arrivals rose by a third, a wait that rose by more than a third is the expected result.

The paper’s structural model says capacity didn’t stay fixed. It estimates that agents raised coding productivity by 73.7 percent and cut review productivity by 7.0 percent, and that firms moved labor accordingly: coding labor down 22.7 percent and review labor up 43.4 percent. Those are model estimates, not observations. If they’re right, firms had already shifted a large amount of effort into review, and the wait still rose by more than half.

## What the code-review literature adds

Software engineering researchers have studied review latency for two decades. Their work explains the mechanism, and it also says how much weight a figure like 3.56 days can carry.

On mechanism, the largest study I found is Xunhui Zhang and colleagues’ 2022 paper in *Empirical Software Engineering*. They gathered 63 factors from earlier work and modeled latency on 3,347,937 pull requests from 11,230 GitHub projects. Their abstract puts it plainly: “The existence of comments is most important when closing pull requests,” along with two other cases. When there are comments, the latency of the first comment matters most. They also find that the number of open pull requests on a project, which they call workload, pushes latency up, and that workload rises steeply with team size: a median of 6 open pull requests on small teams, 13 on mid-sized ones and 77 on large ones. Chen and Stratton find both inside firms. After agents, more pull requests got a comment (an imprecise 13.1 percent rise), each one got more comments, and by the arithmetic above, about twice as many were open at once. Comments and workload are among the strongest predictors of a slow merge in the open-source data.

On baselines, the standard comparison is Caitlin Sadowski and colleagues’ 2018 case study of review at Google, built on logs of 9 million reviewed changes. They report that “the overall (all code sizes) median latency for the entire review process is under 4 hours.” They contrast that with Rigby and Bird’s earlier median time to approval of 17.5 hours at AMD, and they credit Google’s speed to small changes (a median of 24 lines modified), usually a single reviewer, and “expectations around quick turnaround times for review.”

Divide 3.56 days, about 85 hours, by 4 and Jellyfish’s customers look twenty times slower than Google. That comparison doesn’t hold. Sadowski’s figure is a median over reviewed changes. Chen and Stratton’s is a mean over pull requests, from submission to merge, and it includes CI runs, weekends, and the time an author takes to address comments. A pull request can’t take less than zero days, but it can sit open for a month, and one like that moves a mean far more than it moves a median. So a 56.1 percent rise in the mean is consistent with a typical pull request that waits a bit longer plus a growing tail that waits much longer. The paper’s appendix plots firm-level distributions, but the headline effect is on the mean. I’d want the effect at the median and at the 90th percentile, because what I want to know is whether the typical change got slower or a stuck minority got stuck for longer.

The measure is also one that engineers care about directly, which cuts both ways. In Gunnar Kudrjavets and Ayushi Rastogi’s 2023 survey of 75 industry and 36 open-source developers, respondents named time-to-merge as “the essential code review metric to improve.” A metric that teams actively manage responds to management, and these are firms that pay for a platform to monitor engineering activity. Once agents arrive, some will set review SLAs, some will let authors self-merge small changes, and some will add a senior sign-off for AI-written code, as one engineer in the paper’s interviews describes. The firm-level average combines all of those responses.

## What the paper can and cannot say

The design is careful, and the authors list most of its limits themselves. A few matter for the review result.

Agent adoption is detected from traces: an API integration for Claude Code, bot accounts, and signatures such as “Co-authored-by” in commit messages and pull request bodies. An engineer who uses an agent and deletes the trailer is invisible to it. The paper notes that this makes measured take-up a lower bound. It matters less for the firm-level estimates, which date adoption by the first signal, than for anything at the person level.

Larger firms adopted earlier, and the paper controls for firm size. Earlier adopters could still differ in ways a size control misses, and one of the most obvious is how they review code. In the robustness checks the paper reports, the pre-adoption coefficients stay close to zero, which helps.

The data partner sells engineering analytics, and AI’s effect on engineering throughput is the product. The paper says the manuscript was reviewed by Jellyfish only to check that it doesn’t disclose proprietary information, not for its scientific content. I take that at face value. It’s still worth knowing that no one outside the research agreement can rerun these numbers.

The obvious fix is to let AI review the code too. As of July 2026, 79.1 percent of the firms had used an AI code review tool. But AI wrote only 23.3 percent of review comments, and only 10.8 percent of pull requests got even one AI comment. The tools are installed. The approvals still come from people.

## What I’d take from it

In October I wrote about a different gap of the same kind. An [NBER paper by Demirer, Musolff and Yang](https://gautamparab.com/writing/six-to-one-on-two-clocks/) found agent effects shrinking from commits to projects to releases in GitHub data. Chen and Stratton’s contribution is to locate the shrinkage in a specific stage inside firms and put a clock on it. That’s a more useful finding than “AI makes engineers N percent more productive,” because it tells a manager where to look.

The paper’s own simulations show what’s at stake. If review productivity stays where it is, the model predicts output up 57.8 percent by 2031 and employment down 10.3 percent, with output leveling off once review binds. If review productivity keeps pace with coding productivity, it predicts output up 341.4 percent and employment down 76.2 percent. Those are model outputs with large assumptions behind them, and I wouldn’t quote either as a forecast. What separates the two scenarios is review productivity, and in this model it decides how much of the coding gain reaches anything a customer sees.

For a team that has adopted agents, the practical reading is simple. Lines of code and pull requests opened are now the cheapest numbers in the building. Measure what’s waiting for review, look at the tail rather than the mean, and expect queueing to make the wait grow faster than the work. If reviewers were near capacity before the agents arrived, a third more pull requests was never going to cost only a third more waiting.

**References**

1. Chen, F. and Stratton, J. (2026). [*Artificial Intelligence in the Firm: Bottlenecks in Software Production*](https://fion.ac/jellyfish.pdf) . Harvard University job market paper; current version 14 November 2026, first version 7 January 2026.
2. ComplexDiscovery (2026). [*Harvard researchers find AI coding agents shifted the bottleneck to code review*](https://complexdiscovery.com/harvard-researchers-find-ai-coding-agents-shifted-the-bottleneck-to-code-review/) . 17 November 2026.
3. Demirer, M., Musolff, L. and Yang, L. (2026). [*Writing Code vs. Shipping Code: Productivity Effects Across Generations of AI Coding Tools*](https://www.nber.org/papers/w35275) . NBER Working Paper 35275, issued May 2026, revised September 2026.
4. Zhang, X., Yu, Y., Wang, T., Rastogi, A. and Wang, H. (2022). [*Pull request latency explained: an empirical overview*](https://doi.org/10.1007/s10664-022-10143-4) . Empirical Software Engineering, published 4 July 2022.
5. Sadowski, C., Söderberg, E., Church, L., Sipko, M. and Bacchelli, A. (2018). [*Modern code review: a case study at Google*](https://doi.org/10.1145/3183519.3183525) . Proceedings of the 40th International Conference on Software Engineering: Software Engineering in Practice, May 2018.
6. Kudrjavets, G. and Rastogi, A. (2023). [*Does code review speed matter for practitioners?*](https://doi.org/10.1007/s10664-023-10401-z) . Empirical Software Engineering, published 22 November 2023.
7. Little, J. D. C. (1961). [*A Proof for the Queuing Formula: L = λW*](https://doi.org/10.1287/opre.9.3.383) . Operations Research, 9(3), 383-387, June 1961.
8. Kingman, J. F. C. (1961). [*The single server queue in heavy traffic*](https://doi.org/10.1017/S0305004100036094) . Mathematical Proceedings of the Cambridge Philosophical Society, 57(4), 902-904, October 1961.
