Engineering
The Review Bottleneck
AI coding agents write pull requests faster than any team can read them, and the bottleneck has moved to the one step nobody automated.
The queue nobody planned for
A pull request queue at a mid-size engineering organization used to grow because developers were slow to write code. It now grows because agents are fast. The Harvard study measured the shift directly: AI coding agents moved the bottleneck to code review. Teams using agents generated pull requests at a pace that outran the humans responsible for reading them.
The finding is mechanical, not philosophical. A developer using an agent can produce a reviewable diff in minutes. The reviewer still needs to understand the change, check for regressions, verify that the logic matches the ticket, and decide whether the tradeoffs are acceptable. That cognitive load did not shrink when the diff arrived faster. It grew, because the reviewer now has less context about how the code was written and why a particular approach was chosen.
Call it the review bottleneck. Every organization running agents at scale is hitting it, whether they have named it or not. The symptoms are familiar: PR age climbing, review depth falling, senior engineers spending entire days approving code they did not write and cannot fully trace. The queue is the new constraint.
What makes the review bottleneck different from an ordinary staffing problem is that adding more reviewers does not solve it cleanly. The reviewer needs domain knowledge of the system being changed. An agent can open a PR against any service. The reviewer who can approve it is usually the same person who would have written the code by hand. Parallelism at the generation layer creates serialization at the review layer.
More models, same funnel
The generation side accelerated again this week. OpenAI released GPT-6.2 in two variants: Astra for professional work and Sol for everyday tasks. Microsoft shipped MAI Code 2 and MAI Code 2 Flash, purpose-built for code generation. Tencent released Hy4 Flash. Three vendors, one week, all pushing generation throughput higher.
Early reports from developers testing GPT-6.2 Astra on robotics workflows describe debug time dropping from hours to minutes. That is a real productivity gain on the authoring side. It also means every engineer with access to Astra can now produce diffs at a rate that would have required a small team six months ago. The funnel between generation and merge did not widen.
Microsoft's framing is telling. The company announced new first-party models alongside updates to agentic AI continuous improvement. The models produce more code. The continuous improvement layer is supposed to help organizations absorb it. That pairing acknowledges the problem. Whether the tooling solves it is a different question. PostHog's engineering team published a decision framework this week arguing that not everything needs an LLM. The implication: some of the code agents produce should never have been generated in the first place.
The review bottleneck is not a temporary gap between model releases and tooling releases. It is structural. Every improvement in generation speed that is not matched by an improvement in review capacity makes the queue longer. The models shipped this week made it worse.
The assumption the pipeline broke
Most engineering organizations designed their review process around a ratio. One developer writes code, one or two developers review it, the queue stays manageable because generation and review run at roughly the same speed. The ratio held for years because a human writing code and a human reading code operate on the same cognitive clock.
Agents broke the ratio. A single developer with an agent can now sustain the output of three or four developers. The review side of the equation did not change. The reviewer still reads at human speed, still needs to understand the system, still carries the liability for what ships. The 1:1 ratio became 4:1 overnight. At some organizations, it is higher.
Here is the reversal. The industry spent two years optimizing for developer velocity. Faster models, better autocomplete, longer context windows, agentic loops that write entire features from a ticket. All of that investment assumed that writing code was the bottleneck. The Harvard data says the bottleneck moved. The investment thesis did not follow it.
Bank CEOs and NSA officials told Congress this week that AI-driven patches are behind a string of outages. The mechanism is exactly the review bottleneck in production. Code generated fast, reviewed under pressure, merged without full comprehension, deployed into systems where a regression costs millions. The outages are the queue's downstream signal.
CI for the agent era
StarSling, a Y Combinator P25 company, launched this week with self-improving CI for agent-volume repos. The pitch: when agents open hundreds of pull requests a week, the test suite and integration checks need to evolve as fast as the code. Static CI configurations written for human-paced development cannot keep up.
The product category is new. Traditional CI runs a fixed set of checks against every PR. StarSling's approach adjusts the check surface based on what the agent changed and what failed before. The idea is that if agents produce code at a pace humans cannot review line by line, automated checks have to catch what the reviewer would have caught. That shifts some of the review burden from a person reading a diff to a system running targeted tests.
Whether that shift is sufficient depends on what review actually catches. A test suite verifies behavior. A reviewer verifies intent. The test tells you the function returns the right value. The reviewer tells you it was the right function. Automated CI can absorb some of the mechanical load. The judgment layer, whether this change should exist at all, remains human.
Cerebras shipped disaggregated inference the same week, and an open-source team launched TrnRT, an inference engine for AWS Trainium. Both reduce the cost and latency of running large models. Both make it cheaper to generate more code. Neither addresses the review constraint. The infrastructure layer is building capacity for a pipeline whose narrowest point is a person reading a diff.
OpenAI's own moves illustrate the asymmetry. The company released computer-use agents for healthcare teams, extending agent autonomy into domains where errors carry regulatory and clinical consequences. The generation side gets more capable. The verification side gets more critical. The gap between them widens.
Staff the constraint, not the throughput
The review bottleneck does not resolve by making agents smarter. A better agent produces a better diff, but the reviewer still needs to verify that claim. The resolution comes from treating review capacity as the binding constraint and staffing it accordingly.
Three moves that change the shape of the problem.
Scope the agent to the reviewer's capacity. An agent that can open twenty PRs a day against a system whose maintainer can review five is producing waste, not velocity. Cap agent output per service to what the domain expert can absorb in a review cycle. This feels like throttling progress. It is throttling risk.
Invest in review tooling, not generation tooling. The next dollar of engineering productivity spend should go toward tools that make review faster and more reliable. Diff summarization, automated invariant checking, change-impact analysis, test generation keyed to the specific lines an agent touched. StarSling is one entry in what should be a category. The LanceDB raise of $57.5M for multimodal data infrastructure shows capital flowing to training infrastructure. Comparable investment in review infrastructure has not materialized.
Make the reviewer's judgment the artifact. When a human approves an agent-generated PR, the approval should carry structured metadata: what the reviewer checked, what they deferred to CI, what assumptions they accepted. That record is the organization's defense when something breaks. It is also the training signal for the next generation of review tools. Without it, approval is a checkbox. With it, approval is an audit trail.
The banking outages testified to in Congress this week are the cost of skipping this step. Code moved through a pipeline faster than judgment could follow. The agents did what they were asked to do. The pipeline did not ask anyone to verify.
The PR queue at the organization that opened this story is still growing. The agents that fill it got faster this week. The reviewers did not. The bottleneck is a person reading a diff, and that person's calendar has not changed since Tuesday.
FAQ
Questions
Why has the bottleneck in AI-assisted development moved to code review?
AI coding agents generate pull requests much faster than humans can review them. Harvard researchers confirmed that agents shifted the constraint from writing code to reading it. Reviewers still need domain knowledge and time to verify intent, and that cognitive load did not shrink when diffs started arriving faster.
How do AI-generated code outages relate to the review bottleneck?
Bank CEOs and NSA officials told Congress that AI-driven patches are behind a string of outages. The mechanism is code generated fast, reviewed under pressure, and merged without full comprehension. When review capacity cannot keep up with generation speed, defects slip through the pipeline into production.
What can engineering teams do to address the code review bottleneck?
Teams should measure review latency rather than generation speed, cap agent output to match the number of qualified reviewers per service, and require structured approval metadata on every agent-generated merge. Investing in review tooling such as diff summarization and automated invariant checking addresses the constraint directly.
We build AI that does real work in your business. Then we prove it.
Five steps. Each one ends with something on paper - proof it moved your number, and proof it's safe to run.