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).
Bar chart: merging one change into a 3M-file repo takes a median of 21 ms for 10 files, 59 ms for 100 files, 227 ms for 500 files and 364 ms for 2,000 files, all far below the 2.9 seconds available per merge at 30,000 merges a day.
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.
Dot plot on a log scale of the cost to read a million tokens of code: fetching it as bytes costs $0.00004, an agent reading it costs $4 on Opus 5.5 or $10 on Fable 5.1, and careful human review costs about $25,000.
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.