Reviewing Intent, Not Lines

Thirty Thousand a Day

In May 2026 Anthropic merged around 2,500 code changes a day. By September it was merging more than 30,000. The figures come from an engineering post the company published on October 13, “Redesigning source control at Anthropic”, and the post is clear about what drove the rise: Claude, now building services “at a speed and scale we haven’t seen before.” CI alone was checking out the code on the order of 25 million times a day. Fetched naively, the post notes, that would have been over 600 petabytes of git traffic.

The post’s opening claim is blunt: “coding is no longer the bottleneck to building systems or doing research.” The bottleneck moved to everything built around the assumption that people write code: “all of the developer infrastructure built for human scale: source control, builds, and CI.” Most of the post is about that infrastructure. The most consequential paragraph is about people.

When the Plumbing Is the Bottleneck

Git was designed for a world of people working apart. “Every clone is a complete, self-contained repository that can compute diffs, read history and blame, and check out any revision while fully offline.” Anthropic found it was using git the opposite way: “as a centralized system with one authoritative copy, but nearly all of our clients were agents and jobs that are online by definition.” So a seven-person team built Scion, a source control system that assumes its clients are always online, and moved the monorepo onto it in five months. Its infrastructure is 200 times smaller than the git mirrors it replaced.

Process changed with it. A merge queue with a global lock, the industry’s standard way to keep changes from colliding, stopped making sense when “hundreds or even thousands of changes can merge while tests are running.” Anthropic moved to testing after merging and before deploying, and accepted that changes would sometimes conflict, because “Claude can typically fix these conflicts faster than humans can even identify them.” The post is careful about scope: Scion “is by no means a suitable replacement for git for general use.” The system is particular to one company. The lesson inside it is not.

Two Ways to Be Wrong

“All of the engineers who worked on this system would now rate Claude as better at writing code than them.” And yet: “Very often, we found that the role of the engineers was to tell Claude ‘no.’” The post gives two examples, and they fail in opposite directions.

In the first, agents took a shortcut that broke the design. They “will sometimes violate core system constraints to satisfy a pattern that should never have been allowed in the first place” — during the migration, several systems tried to find when a change had merged by reading the commit log line by line instead of asking the code review tool, which already knew. In the second, the code did too much. An automated adversarial review, which the post calls “incredibly effective” but sometimes “myopic,” was “overly defensive about trusting another internal service,” and Claude responded by adding “excessive validation and complexity.”

Neither failure is a bug in the ordinary sense. Each compiles; each could pass its tests. What each violates is a decision made above the code — which system is the source of truth, how much one internal service should trust another. Those decisions were never in the diff. They were in the engineers.

Intent Is the Unit of Review

The post states the consequence plainly: “Our team members still review every change request for the system, but they now examine the intent of the change as opposed to reading every line of code.” Review did not disappear. Its unit changed, from lines to intent.

That shift has been the working premise of two pieces of this site’s own work, arrived at independently and from the other end. Governance-Driven Design argues for formalising intent before the machine runs, so that correctness is defined upstream rather than inspected afterwards. Intent-as-Infrastructure describes systems where a bounded vocabulary encodes the what, a model generates the how, and human judgment “enters at the moment it belongs.” Anthropic’s post is not about either, and endorses neither. It reaches the same place from operational necessity: at 30,000 changes a day, the only review that scales is review of intent.

There is a real difference worth keeping, though it is narrower than it first looks. Anthropic already writes intent down before the work begins: its AI-native SDLC playbook, published August 21, opens each piece of work with an intent.md — “what is wanted, why, and under which constraints” — which the product owner reviews and corrects before it is committed. Per-change review then catches what that file did not anticipate; there, the “no” arrives once a pattern has already appeared. Governance-Driven Design works the gap between the two: whether the refusals that review keeps repeating can migrate upstream, into constraints the generation must satisfy, so that “a pattern that should never have been allowed” is never generated at all. Both are answers to the same question. One catches the drift; the other narrows the room it has to happen.

What Tests Cannot Hold

What the Gauntlet Can’t See made a related point about a well-known engineer who stopped reading his agents’ code and trusted tests instead: tests check whether code matches a belief someone held in advance. They cannot check whether the belief was right. Anthropic’s two examples are exactly that gap. A test suite would not object to reading the commit log; it works. It would not object to extra validation; it is safe. Only someone holding the design objects — and the post is honest that this is now much of what engineers do.

The pattern is not only about code. A week earlier, a release of machine-written mathematics left specialists with more answers than they could yet understand — the subject of The Answers Arrived First — and an AI-assisted survey of the Nazca desert had already shown archaeologists the same shift, from searching to screening and walking. Each time, production got cheap and the bottleneck moved to the people who decide what counts.

The Word That Scales

The general shape is older than source control. When a thing becomes abundant, value moves to whatever is still scarce, and in software that is now judgment about what should exist. Thirty thousand changes a day did not make engineers less necessary; it changed the instrument they play. The keyboard matters less. The design matters more, and the most frequent expression of the design is a refusal.

The post’s numbers will be quoted for their size. The sentence that will matter longer is the quiet one in the middle: very often, the role of the engineers was to tell Claude no.

Related