TL;DR: On October 13, 2026, Anthropic published an engineering post describing how it replaced git for its monorepo with Scion, an in-house version control system, after merge volume grew from ~2,500 code changes per day in May 2026 to more than 30,000 per day by September — a 12x jump in four months, driven by AI agents committing code rather than humans typing it. A team of seven built Scion plus a code review tool and migrated fully in five months. The headline numbers: a ~100 GB main branch history, ~25 million CI checkouts per day, a 200x smaller CPU/memory footprint than the git mirror fleet it replaced, and checkouts that dropped from minutes to seconds. None of this ships as a product — Anthropic says plainly that “Scion is by no means a suitable replacement for git for general use.” The transferable part is the workflow discipline: trunk-based merges with no long-lived branches, machine-queryable history instead of log scanning, post-merge testing instead of a global merge queue, and humans reviewing intent rather than every line.

Figure	Value	Source
Merges/day, May 2026	~2,500	Anthropic engineering blog, Oct 13 2026
Merges/day, September 2026	30,000+	Same post
Main branch history	~100 GB (working copy >25 GB compressed)	Same post
CI checkouts/day	~25 million (600+ PB/day git traffic if fetched naively)	Same post
Team that built Scion + review tool	7 people, 5-month migration	Same post
Footprint vs. old git mirror fleet	200x smaller CPU/memory	Same post
Checkout speed	Minutes → seconds (~2 orders of magnitude)	Same post
Cache hit rate per tier	Above 99%	Same post

Honest take: This is the first first-party account from a major lab of AI agents outgrowing git — not as speculation, but with before/after merge counts. Almost none of Scion’s architecture applies below roughly a thousand merges a day. What does apply, today, at solo-developer scale: the post is a preview of what breaks first when you let agents commit autonomously, and every one of those failure modes has a cheap git-native countermeasure you can set up this week.

What did Anthropic actually build?

Scion is a client-server version control system that assumes the client is always online — the opposite of git’s every-clone-is-a-full-replica model. The server owns history, blame, commits, merges, and rebases; clients keep a bounded local cache and fetch only the trees and blobs they need. There are no packfiles and no full copy of the repository anywhere, including on the server — data is content-addressed and distributed. The write unit is a “changeset”: a server-created write-ahead-log entry storing files changed relative to the first parent, with content-addressed pointers to blobs.

The same seven-person team also shipped Antique (a code review tool), code search, and source-control IAM in the same five-month window — a window the post notes began around when Claude Mythos Preview and Claude Tag became available internally.

Three design decisions stand out against git’s defaults:

git assumption	Scion decision	Why it changed
Branches/tags are cheap, use freely	Refs discouraged except main + release branches; moving a ref is a compare-and-swap on one Spanner row	Global state every server must agree on caps scaling
Merge locally, push the result	Commits, rebases, and merges all happen server-side; nothing to push	Clients (mostly agents) are “online by definition”
Serialize merges to keep main green	No global merge queue lock; post-merge and pre-deploy automated testing catch conflicts	A lock serializing 30,000 merges/day is itself the bottleneck

That last row contains the sentence most worth quoting: concurrent changes can conflict, but “Claude can typically fix these conflicts faster than humans can even identify them.” Anthropic chose to let semantic conflicts land and get fixed, rather than prevent them — because the fixer is now faster than the gate.

Did AI agents really cause the 12x merge growth?

Yes, by Anthropic’s own framing. The post states that agents and automated jobs are nearly all of Scion’s clients, and attributes the scaling problem to Claude’s coding ability — the same capability that then helped solve it. The line that should reframe how you think about your own backlog: “the latent demand for merging code is practically infinite.” Every bottleneck Anthropic removed produced more code production, not a steady state. Coding stopped being the constraint; infrastructure built for human-scale behavior became the constraint.

Two second-order effects are more interesting than the raw count:

Engineers became the brakes, not the engine. “Very often, we found that the role of the engineers was to tell Claude ‘no.’” The concrete example in the post: multiple agent-built systems “tried to brute force looking up when a change merged to main by linearly reading the commit log” — functionally correct, catastrophically unscalable at 30,000 merges a day. Agents optimize for the task in front of them, not for the system’s constraints. Someone (or some policy) has to hold the constraints.

Review shifted from lines to intent. Anthropic says humans still review every change — but they review what the change is for, not each diff hunk. At 30,000 merges a day, line-by-line human review is arithmetic nonsense; at your scale, it’s the same shift our own testing found when reviewing agent PRs: the valuable human question is “should this change exist?”, not “is this loop off by one?” (see when to trust AI code review suggestions).

What is the Claude Mythos Preview rewrite, and what does it teach about prompting?

The most practical anecdote in the post: Anthropic’s hand-built git-to-Scion ingestion prototype worked but didn’t scale. They handed it to an early Claude Mythos Preview snapshot — Mythos is the restricted-availability tier Anthropic offers approved organizations, sharing a base model with Fable 5 — and “asked it to rewrite the whole thing, and with no further instructions,” it “produced a version that consumed 20x less memory and was 4x faster” while “preserving all of the implicit invariants around ingestion ordering and data structures.” Separately, Claude found an algorithmic optimization to ancestry queries that an existing index had missed.

The phrase worth dwelling on is implicit invariants — assumptions the original code depended on (ingestion order, data-structure shape) that were never written down as requirements. The model preserved them unprompted. That is a bet you should not copy blindly. The repeatable version of this workflow, at normal scale:

1. Pick components with a hard I/O boundary. A pipeline with defined inputs and outputs can be verified; a module tangled into shared mutable state cannot.
2. State the invariants anyway. Mythos Preview kept them without being told. Your model tier might not. “Preserve ingestion ordering; output must be byte-identical for the test corpus” costs one sentence.
3. Demand a measurable before/after. 20x memory and 4x throughput are falsifiable claims. If you can’t measure the rewrite, you can’t accept it.
4. Rewrite beats refactor when the spec is the tests, not the code. If behavior is pinned by a harness, a from-scratch rewrite is reviewable. If the code is the spec, incremental refactoring stays safer.

How do 30,000 merges a day stay green without a merge queue?

They don’t stay green — they get fixed fast, and that’s the point. Anthropic deliberately did not replicate a global merge-queue lock. Conflicting changes can land; post-merge and pre-deploy automated testing catch the breakage, and Claude repairs it faster than a human would have noticed it. Tiered caching (scion-daemon → scion-cache → scion-server, all speaking the same RPCs, each tier above 99% hit rate) keeps reads cheap, and Claude Tag powers “superfan” agents that each monitor a single component — scion-daemon, scion-cache, the Antique merge queue — and watch for regressions.

The small-scale translation is counterintuitive but holds: if you run multiple agents against one repo, serializing everything through one approval bottleneck (you) recreates Anthropic’s problem in miniature. The alternative that mirrors their design: required CI checks plus auto-merge, fast revert as the recovery path, and letting the agent resolve its own merge conflicts before you ever look. We covered the multi-agent mechanics in parallel AI coding agents orchestration.

What should you change in your own agent workflow this week?

This site is itself a working example: the repo behind aicoderscope.com is maintained by a scheduled Claude agent that researches, writes, commits, and pushes three times a day, with no human in the loop per run. Measuring the last 30 days:

$ git log --since="30 days ago" --oneline | wc -l
50
$ git log --since="30 days ago" --pretty=%s | awk -F: '{print $1}' | sort | uniq -c | sort -rn | head -5
     15 Log
     15 Add
     11 Queue
      3 Improve
      2 Fix

Fifty agent commits in 30 days — a rounding error against 30,000 a day, but already enough to hit the first agent-scale failure mode. Our publish pipeline originally appended its run log to the same Markdown file that held the agent’s rules. Within months the file had grown to 609 KB of append-only history — past the 256 KB limit the agent’s own file-reading tool could handle, which meant the agent could no longer read its own rule book. The fix was Scion’s “derived data” lesson in miniature: history moved to a dedicated append-only log file, the rules file holds only rules, and the source of truth for “what’s published” became a directory listing instead of a log scan. Agent-generated history grows without mercy; anything that reads it linearly will eventually break.

The commit-prefix convention in that output is the second half of the same lesson. Because every commit message is machine-parseable (Add:, Fix:, Queue:), answering “what did the agent publish this month?” is one git log --grep='^Add:' away — no linear scan, no reading diffs. That’s the solo-scale version of the constraint Anthropic had to enforce when its agents brute-forced the commit log.

The rest of the checklist, scaled down from the post:

1. Trunk-based, short-lived branches only. Scion discourages refs for a scaling reason you don’t have — but agent-created branches that never get deleted rot fast at any scale. Name them predictably (agent/<task-id>), merge or kill them within a day.
2. Pin git discipline in CLAUDE.md, as prohibitions. Anthropic’s engineers spent their time saying “no”; your project memory can say it for you: no force-push, no history rewrite, git revert not git reset on published history, no amending pushed commits. (Our Claude Code agent skills guide covers where these rules live and what they cost in context.)
3. Make CI the gate, not yourself. Required checks + auto-merge + fast revert beats being the human merge queue for your own agents.
4. Budget for the token bill before the infra bill. At 1–50 developer scale, the cost that grows 12x alongside agent commit volume is inference, not storage. A commit loop that runs 50 sessions a day on a flagship model is a three-figure monthly line item — the measured productivity data (2x, not 10x) should set that budget, and heavy always-on loops are exactly where a local backend on your own GPU stops being a hobby and starts being the cheaper option (hardware math at runaihome.com’s VRAM-to-model guide).

Does any of this apply at your scale?

Applies to you if: you run two or more agents that commit autonomously (Claude Code sessions, Cursor background agents, scheduled jobs), you operate a monorepo where CI checkout time already annoys you, or your team is debating how much human review agent commits need. The failure sequence Anthropic hit — history as a hot path, humans as the merge bottleneck, agents ignoring system constraints — arrives in the same order at smaller scale, just later.

Interesting but not actionable if: you commit manually, review every line yourself, and your repo fits comfortably in a laptop clone. Git is nowhere near its limits for you, and Anthropic says so itself — Scion targets “very large monorepos with many engineers or agents,” and there is no public release. Nothing announced on October 13 changes which coding tool you should use today; the current tool rankings are in our October 2026 agent leaderboard analysis.

The reason to read the post anyway: it’s a dated, numbers-attached record of the moment one company’s code production decoupled from its headcount. 2,500 to 30,000 daily merges in four months is what “the latent demand for merging code is practically infinite” looks like when it stops being a slogan.

FAQ

Can I use Scion for my own projects? No. Scion is internal to Anthropic, has no public release, and the post states “Scion is by no means a suitable replacement for git for general use.” Anthropic says it plans to share ideas so existing git platforms can adopt parts of the model — watch for that rather than a product.

Did Anthropic confirm AI agents are the source of the merge growth? Yes. The post describes agents and automated jobs as nearly all of Scion’s clients and credits Claude’s coding ability with creating the scaling problem. The May-to-September window (2,500 → 30,000 merges/day) coincides with internal availability of Claude Mythos Preview and Claude Tag.

What is Claude Mythos Preview? An early internal snapshot of Claude Mythos, the tier Anthropic makes available to approved organizations without the additional dual-use safety measures that ship in Claude Fable 5; the two share a base model. The Preview snapshot in this story is an internal research version — not something you can select in Claude Code or Cursor today.

Do humans still review code at Anthropic? Per the post, yes — every change — but review focuses on the intent of a change rather than every line. Directory-level permissions and semantic approval rules (distinguishing comment-only changes from logic changes) carry part of the load reviewers used to.

Sources

• Redesigning source control at Anthropic — Anthropic Engineering (published Oct 13, 2026; all merge-volume, architecture, and performance figures)
• Anthropic announcement thread on X (2,500 → 30,000 merges/day summary)
• Anthropic Reinvents Source Control As Claude Floods the World With Code — Slashdot
• Anthropic’s Scion Shows Why AI Agents Are Forcing a Rethink of Source Control — DEV Community
• Claude Fable 5 and Claude Mythos 5 — Anthropic (Mythos tier background)

Last verified October 15, 2026. Scion is unreleased internal software; all figures are Anthropic’s own reporting.

Know which coding tool is worth paying for

Hands-on comparisons of AI coding assistants and what each one costs to run — including the local-model path. Sent only when something changes. Unsubscribe anytime.

Email address Subscribe