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

15 Oct 2026

Anthropic now lands more than 30,000 changes a day in its monorepo. To keep up, it [replaced how Git distributes the repo](https://www.anthropic.com/engineering/redesigning-source-control). 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](https://en.wikipedia.org/wiki/Merkle_tree) at their finest).

```chart
id: merge-time-vs-budget
type: vertical bar chart (one series) with one horizontal dashed reference line
title: "Merging one change takes under half a second"
subtitle: "Typical time to merge a change into a 3M-file repo, by how many files it touches"

x-axis:
  kind: categorical, in this order
  title: "Files changed in the merge"
  categories: ["10 files", "100 files", "500 files", "2,000 files"]

y-axis:
  kind: linear, starts at 0
  unit: seconds (data is in milliseconds)
  range: 0 to 3.5 s
  gridlines and tick labels: "0 s", "1 s", "2 s", "3 s"

series:
  name: "Median merge time"
  color role: accent (all four bars the same color)
  data (milliseconds):
    - "10 files":    21
    - "100 files":   59
    - "500 files":   227
    - "2,000 files": 364
  value labels: above each bar, bold, formatted "21 ms", "59 ms", "227 ms", "364 ms"
  hover text: "<category>: <value> ms", e.g. "500 files: 227 ms"

reference line:
  value: 2,880 ms (2.9 s), horizontal, dashed, color role: reference
  label (left-aligned, just above the line): "At 30,000 merges a day, each merge can take up to 2.9 s"
  derivation: 86,400 seconds in a day ÷ 30,000 merges = 2.88 s

point of the chart: all four bars sit far below the dashed line; even the 2,000-file merge uses about 13% of the time available.

caption: "Measured on Git 2.43 in a 4-vCPU sandbox · median of 30 runs per size"
alt text: "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.

```chart
id: read-cost-ladder
type: horizontal dot plot (lollipop style) on a logarithmic x-axis, one row per reader
title: "Reading a million tokens of code costs from $0.00004 to $25,000"
subtitle: "Price per million tokens read, by who reads it; log scale, each gridline is 10×"

x-axis:
  kind: logarithmic, base 10
  unit: US dollars per million tokens read
  range: $0.00001 (10^-5) to $100,000 (10^5)
  gridlines: one vertical gridline at every power of 10 from 10^-5 to 10^5 (11 lines)
  tick labels (every second power): "$0.00001", "$0.001", "$0.1", "$10", "$1,000", "$100,000"

rows, top to bottom (cheapest first). Each row has a bold or regular label on the left, a smaller secondary note under it, a thin grey line from the left edge of the plot to the dot, and the dot:
  1. label: "Fetch or checkout (bytes)"   (regular weight)
     note:  "the layer Scion rebuilt"
     value: 0.00004   → value label "$0.00004" (to the right of the dot)
     dot color role: muted
  2. label: "Agent reads it"              (bold)
     note:  "Opus 5.5 input price"
     value: 4         → value label "$4.00" (right of the dot)
     dot color role: accent
  3. label: "Agent reads it"              (bold)
     note:  "Fable 5.1 input price"
     value: 10        → value label "$10.00" (right of the dot)
     dot color role: accent
  4. label: "Human careful review"        (regular weight)
     note:  "$600k a year, 9 to 5, reading 12k tokens an hour"
     value: 25000     → value label "$25,000" (to the LEFT of the dot, so it stays inside the plot)
     dot color role: muted

value formatting: below $0.01 show 5 decimals ("$0.00004"); below $100 show 2 decimals ("$4.00"); otherwise a whole number with thousands separators ("$25,000").
hover text per dot: "<value> per million tokens"

how each value is derived:
  - bytes: $0.01 per GB of transfer ÷ 250 million tokens per GB (4 bytes per token) = $0.00000000004 per token = $0.00004 per million tokens
  - Opus 5.5: $4 per million input tokens (Anthropic API list price, October 2026)
  - Fable 5.1: $10 per million input tokens (Anthropic API list price, October 2026)
  - human: $600,000 a year ÷ ~2,000 working hours (9 to 5, ~250 days) = ~$300 an hour; at 12,000 tokens read per hour = $25,000 per million tokens

point of the chart: the readers span about nine orders of magnitude; an agent read costs ~100,000× a byte fetch, and a human read costs ~6,000× an agent read.

alt text: "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.

---

[Original post](https://mbednarski.com/blog/2026/10/15/) · [All posts](https://mbednarski.com/blog/)
