Blog

"Anthropic Merges 30,000 Changes a Day" Misses the Point

Anthropic now lands more than 30,000 changes a day in its monorepo. To keep up, it replaced how Git distributes the repo. My first guess was that merging had become the bottleneck: 30,000 a day is one merge every three seconds.

It isn't. Merging is cheap; reading is what explodes. Every change is written once and then read hundreds or thousands of times, mostly by machines.

Writing is cheap

A server-side Git merge finishes in well under a second, even for 2,000 changed files on a 3M-file repo (Merkle trees at their finest).

Measured on Git 2.43 in a 4-vCPU sandbox · median of 30 runs per size

Each timing covers everything needed to put a change on main. Synthetic repos of 100k and 1M files took about the same time, so repo size barely matters.

The read to write ratio

Anthropic's post gives about 25 million CI checkouts a day against just over 30,000 merges, roughly 800 checkouts for every change that lands. (The post doesn't say both figures cover the same days, so treat it as an order of magnitude.)

Those checkouts are machines copying files, and only about one in 800 of them ends in a change that lands. The rest are agents planning, testing, reviewing and retrying.

The hierarchy of reads

It's interesting to think about those 25 million checkouts and the costs they incur downstream. Each one hands code to some reader, and what that read costs depends on who the reader is.

Scion fixed the cheapest of these reads: fetching the code. An agent reading code costs about 100,000 times more per token. Human review sits at the top, about 6,000 times above an agent. (We suspect Anthropic engineers don't read much code by hand and are mostly agentmaxing, but an Anthropic engineer's cost was too fun to leave off the chart.)

What follows

Maybe agentic coding should be measured in reads per write. I'd bet humans still beat agents on that metric today, because we keep context between sessions: when a file changes, an engineer reads only the delta and updates the model of the system already in their head, while every agent session re-reads the files from scratch.

I see two ways to attack it. One is an architecture where a file's cached state doesn't depend on everything that came before it in the context. Today it does, so a file read in one session can't be reused in the next; a separate, position-independent space for code could be cached once per file version and shared. The other is smarter models and harnesses that do more with fewer reads: better planning, fewer retries, less re-checking of work that was already right.