More code and more pull requests do not prove that delivery is faster. A pull request is a proposed code change put forward for checking. If more changes arrive than reviewers can handle, an AI code review bottleneck can form: code waits longer before anyone checks it. This companion to episode 1 explains how to investigate that queue, what Little’s Law can tell you, and three moves to test with a team.

Where the time goes in AI software delivery

Writing code is one step of several. After it is written, work may wait for review, testing, a release or a decision. Faster coding can increase the amount arriving at those steps without increasing their capacity to finish it.

That’s a useful starting point for AI in agile delivery: follow a change through the whole process. Review may be the constrained step, but check where work actually waits before changing it. A shorter review queue is little comfort if the same work now waits for testing.

A post office with one counter

Picture a post office with one counter open. More people arrive than the clerk can serve. The clerk works just as hard, but the queue grows. Asking everyone to join the queue faster will not get their parcels sent sooner.

That is an illustration, not evidence about any particular team. It shows what to look for: changes arriving for review faster than they can be checked. The useful question is how to balance that work, rather than whom to blame.

Little’s Law in plain words

Little’s Law comes from a 1961 paper by J. D. C. Little. Its title gives the formula as L = λW. In a steady system, the average number of items inside equals the average arrival rate multiplied by their average time inside.

Keep the boundaries consistent. If the system runs from ready for review to review complete, count both waiting items and those being checked. The elapsed time covers both stages. The equation describes averages over time; it does not predict when a particular change will finish.

For some simpler backlog arithmetic, imagine 12 pull requests waiting, with reviewers clearing four a day. That represents about three days of queued review work if the changes are comparable and capacity holds. This is illustrative arithmetic, not a measured team or a Little’s Law forecast. If new requests keep arriving faster than four a day, the backlog keeps growing. That overloaded queue does not satisfy the steady-system assumption.

What teams’ data shows

Faros AI, which sells engineering-measurement software, analysed telemetry from 1,255 teams and over 10,000 developers. Its July 2025 report compared each team’s lower- and higher-AI-adoption quarters. It reported 21% more tasks per developer and 98% more pull requests merged per developer, while median review time rose by about 91%.

The figures came from different subsets of the sample. They are observational associations, not proof that AI caused the changes. The report does not establish that all the extra review time was spent waiting in a queue, rather than actively checking code. Later Faros editions report different magnitudes and use different samples or periods, so these are dated findings, not today’s expected result.

The practical lesson is to inspect your own queue. A vendor’s report can suggest a question; it cannot locate your team’s bottleneck for you.

How to investigate the AI code review bottleneck

A growing queue is a reason to investigate workload, availability and blocked decisions before blaming individual reviewers. Trace what each waiting change needs: an available reviewer, specialist knowledge, a test result or a clearer explanation from its author.

Imagine reviewers feeling pressure to clear a growing queue. They might rush and miss a problem. That is an illustrative risk to guard against, not a finding established by the Faros figures. The earlier article on what code review is for when agents write the first draft explains the checks that still matter when code looks convincing.

Three moves to test

Start with one team and agree what counts as ready for review. Then try these changes together:

  1. Limit how much can wait for review. Choose a limit with the team from the work it can check, rather than imposing the same number everywhere. When the queue is full, stop starting new work and help clear or unblock reviews. Keep all started work visible, so a smaller review queue does not conceal an upstream backlog.
  2. Keep pull requests small enough to understand. Split a change into coherent pieces a reviewer can reason about, with its purpose and evidence attached. Small does not mean an arbitrary line count: splitting connected changes can make them harder to assess. Keep the same standard of checking.
  3. Finish before you start. When someone has capacity, ask what they can safely review or unblock before starting another change. If they lack the knowledge to review it, pair with someone who has it. Moving work through the queue must not mean waving it through unchecked.

A queue limit alone does not create review capacity or guarantee shorter waits. It makes the pressure visible and gives the team a rule for responding. If blocked decisions or specialist availability are the constraint, deal with those too.

How you’ll know it’s working

The Kanban Guide, by Daniel Vacanti and John Coleman, defines Work Item Age as elapsed time from a work item’s defined start to today. For this experiment, also track a separate measure: the time since each waiting change became ready for review. End that wait when a reviewer starts checking the change; record active checking separately. That clock starts at review readiness, not when coding began.

Record the oldest waiting change, how many reviews finish, and whether reviewed changes need correcting afterwards. Keep the counting rules consistent. A falling oldest age is useful if work is genuinely finishing; it is misleading if old items are hidden, closed prematurely or rushed through.

After a week, discuss whether waits have shortened without more rework. Keep watching before drawing a firm conclusion. Repeat the experiment with other teams using their own baselines and limits. The companion to episode 2 on checking AI developer productivity explains why before-and-after differences need context.

For a wider view of where AI is straining delivery across your teams, the free AI Delivery Health Check gives you a score, an area to focus on first and one practical thing to try this week.