Anthropic Scion: Why Claude's Code Outgrew Git, and What Replaced It

What happened

On October 13, 2026, Anthropic published Redesigning source control at Anthropic, an engineering post on Scion, an in-house version control system that replaced git for the company's monorepo. Anthropic says coding is no longer its bottleneck. The bottleneck is developer infrastructure built for human scale: source control, builds and CI.

The numbers behind it: Anthropic averaged around 2,500 merged code changes a day in May 2026 and more than 30,000 a day by September. Its chart shows 30,401 merges on September 9. A team of seven built Scion, a code review tool called Antique, code search, a source control IAM system and more, then fully migrated in five months. The Register compared the centralised design to Subversion and noted there will be no open-source release.

This page is the long-form briefing behind the BSH Technologies Instagram carousel.

1. Why git strained at Anthropic's scale

• Git is decentralised. Every clone is a complete repository that can diff, read history and blame, and check out any revision offline. Anthropic says that is the right design for the vast majority of repositories.
• Anthropic's monorepo doesn't fit that model any more. Main-branch history is almost 100 GB, a compressed working copy is over 25 GB, and CI alone runs on the order of 25 million checkouts a day. Fetched naively, that would be more than 600 PB of git traffic a day.
• It had already used the standard workarounds: partial clones, sparse checkouts, shallow clones, repository snapshots and, at the peak, several hundred internal git mirrors. Those got harder to run as the merge rate climbed.
• The key insight: nearly all of its clients are agents and jobs that are always online, so the features that make git great for offline work were working against it.

2. The design principles

• Clients are always online. The client fetches data when it needs it instead of holding a full copy.
• Client-server asymmetry. The server answers history and blame queries and creates commits, merges and rebases. The client keeps a bounded object cache, lays out files and watches the filesystem.
• Source control as an API. Every query the client uses is also exposed by API, so many CI jobs and tools, like automated bisect and revert pipelines, don't need a local repository at all.
• Horizontally scalable. No fully materialised copy of the repo exists anywhere, even on the server, and there are no packfiles to maintain.
• Cheap, lock-free commits. The cost of a commit scales with the size of the change, not the size of the repo. Refs are discouraged except for main and release branches.
• Sparse by design. Sparse and virtualised checkouts mean a job only pays for the files it actually reads.

Anthropic credits prior art in Google's Piper and Meta's Sapling.

3. How Scion works

• The unit of work is a changeset, an entry in a write-ahead log. Instead of pointing to a full tree like a git commit, it lists the files that changed relative to its first parent, with content-addressed pointers to compressed file contents in blob storage.
• Metadata lives in Spanner. Moving a ref is a compare-and-swap on a single Spanner row, separate from creating changesets.
• Blame, path history and commit-graph skip lists are derived data, computed from parents through one generic mechanism. The team can add new indexes, choose eager or lazy computation, and change internals without touching the client.
• Checkouts flow through three tiers: scion-daemon on each node, regional scion-cache servers, and the authoritative scion-server. Because every object is immutable and content-addressed, any tier can answer from cache, and failures stay isolated.

4. The results

• Each tier keeps a cache hit rate above 99%.
• The Scion infrastructure footprint is 200x smaller than the old git mirroring setup in CPU and memory.
• CI and research jobs check out code two orders of magnitude faster, in seconds rather than minutes, and CI alone won back 25% of its CPU capacity.
• Anthropic's command benchmarks show developer "pull latest" dropping from 87 s with git to 3.5 s with its scn client, and a new agent worktree from 7.1 minutes to 5.1 seconds.

5. Built with Claude, steered by engineers

• Anthropic asked an early internal snapshot of Claude Mythos Preview to rewrite its handwritten git-to-Scion ingestion prototype. With no further instructions, the rewrite used 20x less memory and ran 4x faster while keeping the pipeline's invariants.
• The engineers on the team now rate Claude as better at writing code than themselves, but they still owned the system design and trade-offs. Often their job was to tell Claude "no" when an agent tried to break a core constraint or over-engineer against hypothetical risks.
• Claude made it practical to build hermetic simulations, fuzzing and rate limiting on a tight timeline. Claude "superfans" in Slack watch the telemetry for individual components like scion-cache and the Antique merge queue.
• Agent-scale merging also changed CI. Instead of a global lock on the merge queue, Anthropic invests in post-merge and pre-deploy testing and lets Claude fix the conflicts that follow.

6. Not a git replacement for everyone

• Anthropic is explicit: Scion "is by no means a suitable replacement for git for general use." It only makes sense for truly enormous monorepos with tens of thousands of engineers or swarms of agents.
• Adopting it would mean migrating code review, code search and CI too, so there is no public release.
• Instead, Anthropic expects this class of problem to become common within six to 12 months and wants to work with GitHub, GitLab and the open-source community on git servers with comprehensive server-side RPCs, a better negotiation protocol, and sparse and shallow features that compose well.

Why it matters

• The bottleneck has moved. When agents write most of the code, merge volume, checkout cost and CI throughput become the limits, not typing speed.
• Tooling built for humans will be rebuilt. Merge queues, CI and code review all assume human pacing. Anthropic is already rethinking them.
• Small teams can ship big infrastructure. Seven people replaced a source control system in five months while merge volume grew 10x.

What engineering teams can do now

• Measure your merge rate. If AI coding tools are increasing it, watch checkout time, CI queue time and mirror load before they become the bottleneck.
• Use what git already has. Partial clone, sparse checkout and shallow history cut checkout cost for agents and CI today.
• Ask questions server-side. Where your forge offers APIs for diffs, blame and history, CI jobs can skip full clones.
• Keep humans on intent. Review what a change is meant to do and enforce system constraints, so agents don't drift.

Primary sources

• Anthropic Engineering: Redesigning source control at Anthropic (Oct 13, 2026)
• The Register: Anthropic reinvents source control as Claude floods the world with code (Oct 13, 2026)
• Slashdot: Anthropic Reinvents Source Control As Claude Floods the World With Code (Oct 14, 2026)
• Git documentation: Partial clone
• Git documentation: git sparse-checkout
• Sapling SCM (Meta)

How BSH can help

At BSH Technologies we help teams adopt AI coding agents without letting the pipeline become the bottleneck: monorepo and CI tuning, faster checkouts with sparse and partial clones, agent sandboxes, and code review flows where humans focus on intent. If AI-written code is piling up in your repos, our Thrissur engineers can help you scale the infrastructure around it.