At 30,000 Merges a Day, Anthropic Sees Judgment Becoming a Bottleneck

Meta, Cognition, Anthropic and Bain each describe AI agents moving software's bottleneck away from writing code, toward review, judgment and operations. The teams answer by building checks into the agent loop itself.

By September, Anthropic was merging more than 30,000 code changes a day into its monorepo, against about 2,500 in May. This week, Meta, Cognition and Anthropic itself described what agent-written code does to engineering work. They agree that writing code has stopped being the hard part, and that judging and checking what the agents produce has taken its place.

Why cheap code makes checking the scarce step

Code can compile, run and look complete while doing the wrong thing. OpenAI gave a precise example this week, in a post on migrating COBOL programs. COBOL’s fixed-point arithmetic drops excess decimal digits unless rounding is explicitly requested, so a rewrite that rounds instead can run without errors while producing different financial results. OpenAI’s caveat is that putting such migrations into production still requires expert review and testing against the system’s business rules and dependencies.

Meta’s Forum team, which built a new Facebook Groups app with AI handling much of the routine implementation, names the general case. Without verification, the team writes, AI-generated code is “plausible output that no one has confirmed actually works,” which an engineer then has to read, debug and often discard. Taken together, the two examples describe an asymmetry. An agent makes plausible code almost free to produce, while confirming that code still takes tests someone has to write and judgment someone has to exercise.

Volume is what turns that asymmetry into a bottleneck. In a post on its source control, quoted by the developer Simon Willison, Anthropic reports about 2,500 merged changes a day in May 2026 and over 30,000 a day as of September. Its chart, as Willison republished it, peaks at 30,401 on September 9. Those figures count merged changes. They say nothing about the size of each change or how long anyone spent reading it.

Anthropic’s daily merges in 2026: about 1,000 a weekday in January, 6,000–8,000 in mid-July, about 17,000 in early September, a 30,401 peak on Sept. 9.

Vendors report the same acceleration at home. Russell Kaplan, co-founder and president of Cognition, the company behind the coding agent Devin, told McKinsey that Devin now writes roughly 95 percent of the code Cognition ships, and that the company’s total code output grew about sevenfold in six months. Those figures come from the vendor alone. Kaplan also reports that, when Cognition tested it, code volume turned out to be a weak predictor of how much engineering effort a task took.

Four accounts of where the bottleneck went

Four sources say where the constraint now sits. They agree that it has moved, and each names a different place where it landed.

For Meta’s Forum team, it landed on review. Weak signals, the team writes, do not remove the constraint; they “move it from writing code to reviewing code that looks finished and isn’t.”

For Kaplan, it landed on choice and verification. Because teams now direct and review far more output per person, he told McKinsey, the constraint moves from how fast people can write code to how well they can decide what is worth building and verify that it is correct.

For Anthropic, it landed on attention. A report the company published on its own workforce, covered by TechCrunch, suggests “human attention and judgement” are becoming a bottleneck, because Claude produces a deluge of text that people have to read and organize.

For Bain, the consulting firm, it landed downstream, in operations. In a survey of nearly 300 tech and engineering leaders, Bain describes a reliability paradox: AI compresses the cost of building software but can inflate the cost of running it, unless operations are redesigned in parallel. Solve for velocity alone, Bain writes, and the bottleneck moves “from the engineer’s keyboard to the pager.” In the survey, AI’s biggest measurable gains to date are in speed and throughput, and executives expect an almost 150% improvement in the next one or two years. The gain they anticipate in operational resilience is the smallest of every metric Bain measured. Almost two-thirds of executives rank AI applied to coding, testing and reviewing as the most important productivity lever, while observability and incident automation sit near the bottom, cited by roughly one in five.

Even the speed is not a given: Kaplan cites WPP, which had rolled out an AI coding assistant to 500 engineers and seen none of its delivery metrics move. All of these accounts are self-descriptions or opinion surveys, and none is an outside measurement. What they share is a direction, and several of the same teams describe the controls they now build around it.

Control written as code: gates, hooks and a thin router

The control those teams describe comes in two kinds. The first is deterministic: a rule written in ordinary code that gives the same answer every time, where a language model reasons probabilistically and can answer differently from one run to the next. Meta’s data pipeline team built its agent system around that boundary.

The team’s agents add data columns to Meta’s recommendation systems, a job that requires coordinated code changes across three repositories, three programming languages and up to six pipeline stages. Its first design was a single agent that knew everything. It worked in demos, and in production, Meta writes, it “started hallucinating.” The fix was neither better prompts nor a bigger context window. It was giving the central agent less to do.

Meta’s answer is a 1,300-line orchestrator that routes more than 20 workflows to 14 specialized agents and does no domain work itself. Every request follows a fixed seven-step protocol. Steps one to five and step seven are deterministic, and only step six calls a language model, inside one isolated specialist. Step five is a reliability gate that checks for active warnings or required reviewers. Meta reports that preparing the configuration for a new column took three to four days by hand and about a day with its earlier configuration-driven system, and now takes under an hour. About two-thirds of the system’s changes land without significant human edits. Those are Meta’s numbers about Meta’s system.

Meta’s configuration prep for a new data column: three to four days by hand, about a day with the earlier system, under an hour with the thin orchestrator.

The orchestrator does not sideline the model. Meta writes that a better model improves all 14 subagents simultaneously. In this design, code decides what the model works on and when.

The Forum team applied the same logic to verification. A task is complete only once automated tests and visual checks have passed, and hooks run a linter after every agent turn and validate tests before a pull request is created. Every shipped change still carries an engineer’s sign-off, backed by build results, test outcomes and recorded verification sessions attached to the change. How much the team can safely hand to the loop, it writes, “is gated by how much we can trust the verifiers.”

The same pattern works for a single developer. Geoffrey Huntley, quoted by Willison, describes what he does when an agent is not using his diagnostics library. Updating AGENTS.md, the instruction file the agent reads, would leave a gap that drifts, so he writes a pre-commit hook that scans the diff for direct calls to observability modules, fails the commit and injects a prompt telling the agent to use the library. “All of a sudden it’s ten out of ten.” The hook still ends in an instruction to the model, but a rule in code now decides when that instruction fires.

When the reviewer is another model

The second kind of control is a model reviewing the model. The Claude Code team at Anthropic (Addy Osmani, Morgan Westlee Lunt and Qing Wang, quoted by Willison) calls the question of whether a human read the code an imprecise proxy for the real one: what could go wrong with a change, and which check, automated or human, is the right one to catch it. Review now runs continuously, “more like spellcheck while you write,” and most changes have been reviewed and fixed by Claude at least once before a human is asked to look. The team says this catches most routine mistakes and saves the team’s attention for higher-level questions.

Anthropic’s source control post, again as quoted by Willison, names a limit of model review. The company makes extensive use of adversarial review, which Willison, who has been trying it in his own projects, describes as having a model try to find flaws. Anthropic calls it incredibly effective in many ways but says it can also be myopic: skilled engineers needed to steer Claude away from over-engineering parts of the system in response to hypothetical concerns.

Anthropic’s workforce report shows where the remaining human work went. In an April 2026 survey, 20% of employees said their job had shifted “from actually doing work to managing Claudes.” Meeting time per employee rose 20% in a year, and 16% for technical contributors, which Anthropic attributes to the importance of human trust and accountability. On quality, Anthropic acknowledges that more code does not necessarily mean better code, but it has found no indications that code quality is declining. That finding is Anthropic’s own, about its own code.

What it means

Read together, the week’s accounts describe control moving into the loop instead of waiting at its end. The most concrete of these checks are written as code or attached to the change: tests, hooks, routing gates, verification evidence bundled with the pull request. Meta’s Forum team calls its own human-on-the-loop model “the target we are driving toward, not a finished state.”

The open question is whether verification keeps pace with volume. A merge count measures throughput, not the queue behind it. For a team adopting agents, the numbers worth instrumenting are how long changes wait for human review, how many are approved by a model alone, and how often a change that passed its checks later proves wrong. Bain pushes the same question toward operations, and recommends rebuilding measurement so that trust and control are visible alongside velocity.

The harder question is where the judgment comes from. At Anthropic, the share of junior employees in technical departments fell from 21% to 14% since early 2025, and the junior share of technical hires from 27% to 9%. That is one employer, which also sells the tool, and TechCrunch reports no cause for the drop. If verification becomes the core of the job, though, the industry will have to say where engineers learn to verify.

We first looked at the gap between generating and checking in Lean Checks OpenAI’s Proofs; Humans Miss 1 Agent Threat in 3, and at the harness around models in OpenAI’s Own Guide Puts 25 Benchmark Points in the Harness. Ordinary application code has no equivalent of Lean to settle whether a pull request does what the business needs, and this week’s accounts show teams rebuilding the harness to check what the agent produces.

Sources