AI coding agents raised pull requests 36%. Code now waits 60% longer for a reviewer. A 1961 queueing law says what that does to the pile.

A Harvard study of 655 firms found AI coding agents raised pull requests 36% but finished work far less, because code waits 60% longer for review. Little's law explains the pile.

Share
A code editor on a laptop screen showing React source code
Agents made writing changes like this cheaper; reviewing them did not get cheaper. Stand-in photo. Photo: Juanjo Jaramillo on Unsplash.

On 14 November 2026, Fiona Chen and James Stratton of Harvard University posted a new version of their paper "Artificial Intelligence in the Firm: Bottlenecks in Software Production". It tracks 720,542 engineers at 655 companies from January 2021 to August 2026, using work data from the engineering analytics firm Jellyfish. The answer to whether AI coding agents make teams ship more is: much less than they make teams write. Twelve months after a company adopted agents, pull requests opened per engineer were up 35.7%. Jira issues resolved were up 13.7%, and that is only borderline significant. In between, code started waiting 59.9% longer for someone to review it. The code review bottleneck is where the extra output goes.

What did the Harvard study measure?

+35.7%pull requests opened per engineer, 12 months after agents
+26.0%pull requests merged
+13.7%Jira issues resolved (borderline significant)
+59.9%time code waits for a reviewer

Source: Chen and Stratton, Harvard, version of 14 November 2026. Effects of agents on top of assistants; 655 firms, 720,542 engineers.

The design compares companies by when they took up AI tools, with assistants (autocomplete-style tools from late 2022) and agents (tools that write whole changes, from late 2024) measured separately. The numbers above are what agents added on top of assistants. Every stage before review grew a lot: lines of code up 44.0% (marginally insignificant), commits up 36.0%, pull requests opened up 35.7%. Pull requests merged grew less, 26.0%. Then the finished-work measures: Jira issues up 13.7%, epics up 18.0%. Employment didn't move in a way the data can detect (minus 2.6%, not significant).

The review numbers are where it piles up. Time from submission to approval rose 56.1%. Time waiting for a reviewer to pick it up rose 59.9%. Time in active review rose 58.5%, and comments per change rose 38.6%. The authors say it plainly: "Code review becomes the bottleneck."

Didn't the study say agents resolve nothing extra?

That's what I expected to write. The version most people quote is from August. According to BERI's comparison of the two versions, it covered 718 firms through March 2026 and reported about 30% more code and review taking 49% longer, and October headlines summed it up as more code but not more software. The November version is a little kinder to agents: issues and epics now show modest gains. The bottleneck story survived the revision. The "zero" didn't, so I'd stop repeating it.

It's also worth saying what kind of paper this is. It's a job market paper, and the PDF says it "was not reviewed for its scientific content." The data comes from Jellyfish customers, companies that chose to buy engineering analytics. My guess is that makes them more measured and more organised than the average software team, but nobody has shown that either way.

Why does more code mean longer waits?

Merged pull requests per engineer rose 26%. Time from submission to approval rose 56%. Roughly how much bigger is the pile of pull requests waiting at any moment?

About double (1.26 x 1.56 = 1.97). That's Little's law, L = λW, applied to the paper's numbers. My arithmetic, assuming a steady state. Sources: Chen and Stratton, 2026; Little, 2011.

Here's the cross that made it click for me. In 1961 John D. C. Little published a proof of the queueing formula L = λW. The average number of items in a system equals the rate they arrive times the average time each one spends there. In his 50th-anniversary review in Operations Research, Little notes that it "holds under remarkably general conditions." It doesn't care whether the items are customers, parts on a factory floor, or pull requests.

Apply it to the paper's numbers. If merged pull requests per engineer rose 26.0% and the time from submission to approval rose 56.1%, then in a steady state the number of pull requests sitting open per engineer rises by about 1.26 times 1.56, which is roughly 1.97. The pile of work waiting for review about doubles. That's my arithmetic, not the paper's, and it treats approval time as the time in the queue, but the direction isn't in doubt.

Same law, two floors

A factory line

  • Arrivals Parts from a faster upstream machine
  • Bottleneck The slow machine downstream
  • What grows Work in process stacked in front of it
  • What raises output More capacity at the slow machine, or a shorter cycle there

A team using coding agents, 2026

  • Arrivals Pull requests opened, up 35.7%
  • Bottleneck Review, mostly by senior engineers
  • What grows Time waiting for a reviewer, up 59.9%
  • What raises output More people trusted to approve, or less time per review

Sources: Little, Operations Research, 2011, page 545; Chen and Stratton, 2026.

Operations managers use the same law. Little's review quotes the operations version, throughput equals work in process divided by cycle time, and the warning that "any increase in output requires either an increase in work-in-process inventory" or a shorter cycle. Speeding up one machine upstream of a slow one doesn't raise output. It builds a stack of half-finished parts in front of the slow one.

Flow chart of the change after AI coding agents: lines of code up 44%, commits up 36%, pull requests opened up 36%, wait for a reviewer up 60%, pull requests merged up 26%, Jira issues resolved up 14%
Everything before review grew; less came out the other side. Source: Chen and Stratton, Harvard, 14 November 2026 (agent effects at 12 months).

Who is the slow machine?

A long line of cars queued on a road
Speed up the cars behind a slow point and you get a longer line, not more cars through. Stand-in photo. Photo: James Lo on Unsplash.

The paper's answer is senior engineers. 75.7% of reviews of senior engineers' code are done by senior reviewers, against 32.8% for junior engineers' code. One engineer the authors interviewed described a project where "only one senior engineer was allowed to approve changes because he was the expert on the codebase." Another said people "could make a huge number of commits quickly, but code review was still the bottleneck."

That's a familiar picture. In most teams the scarce people are the few who know enough to say yes, and agents give everyone else more to bring them. In a piece last month I looked at AI review finding more Postgres bugs than there was time to fix; it's the same queue seen from the other end. And when I wrote that AI hasn't paid off outside tech, and electricity took four decades, the point was that factories had to be rebuilt around the motor before output rose. This paper is a small, measured case of that.

So what would raise output?

Little's law only leaves two levers: more capacity at the bottleneck, or less time per item there. In practice that means more people trusted to approve, smaller changes that take less time each, or review tools good enough to share the load. The authors' own model predicts output will rise and employment fall in the long run, with smaller effects if the review bottleneck persists.

What doesn't work is the thing that's easiest to measure: more code. A team counting pull requests opened will see a 36% gain and might believe it.

How sure am I?

Established
The paper's estimates and caveats in its 14 November 2026 version (a job market paper, not peer reviewed); Little's law and its generality.
Inferred
That the pile of open pull requests per engineer roughly doubled. It's Little's law on the paper's numbers, assuming a steady state and treating approval time as queue time; the paper doesn't report open counts in the parts I read.
Still a guess
Whether teams adapt (more approvers, smaller changes, AI review) before the queue limits them, and whether Jellyfish customers behave like everyone else.
The claim, in one sentence

Making code cheaper to write mostly makes the review queue longer; a team ships more only when review gets faster or wider, because the queue obeys arithmetic, not effort.

More on Daily Ferment: AI review found more Postgres bugs than there was time to fix and AI hasn't paid off outside tech. Electricity took four decades.

Sources