Anthropic replaced Git with its own system — because Claude writes too much code

Anthropic's daily merged code changes grew more than tenfold in four months — from about 2,500 in May 2026 to over 30,000 by September — as Claude-coded software scaled. Git, designed for humans working offline, became the bottleneck. So Anthropic built Scion, an in-house version control system designed for always-online AI agents, and migrated its monorepo in five months. The main-branch history alone is nearly 100 GB.

Here is a problem only an AI-first company would have: Claude writes so much code that Git is the bottleneck. Anthropic's engineering team published the numbers on October 13, 2026. In May 2026 the company merged about 2,500 code changes per day; by September, that was over 30,000 per day — more than a tenfold rise in four months, with no sign of slowing.

The interesting part is not the growth itself. It is that the tooling built for human-scale development broke under agent-scale load, and Anthropic's answer was to redesign source control from first principles. The result is Scion, an in-house version control system, plus a code-review surface called Antique, code search, a source-control IAM system and tooling to land large amounts of reviewed code — all built in five months.

Why Git stopped fitting

Git is decentralized: every clone is a complete, self-contained repository that can diff, read history and check out any revision while fully offline. For most repositories that is the right design, and a big reason git became the standard. Anthropic's monorepo is not most repositories:

• The main-branch history alone is almost 100 GB; a compressed working copy is over 25 GB.
• Anthropic performs on the order of 25 million code checkouts per day for CI — before counting developer environments, agent sandboxes and research jobs. Fetched naively, that would be over 600 PB of git traffic per day.
• At its peak, Anthropic operated several hundred internal git mirrors to deal with the load. Seeds fell further behind the tip of main between refreshes, and operations that depend on history (diff, blame) got harder on partial clones.

The key insight: "like most companies, we were using git as a centralized system with one authoritative copy, but nearly all of our clients were agents and jobs that are online by definition. The properties that make git excellent for distributed, offline work were actively undermining our ability to scale."

Designing for agents that never sleep

Scion's design follows from that observation. Its three stated principles:

• Clients are always online. Since nearly all clients are agents and jobs, Scion is built around a server that is always reachable; clients fetch data when they need it rather than holding a full copy.
• Client-server asymmetry. In git, any client can be a full server. In Scion, the server answers questions about file history and blame, creates commits, and performs merges and rebases. The client keeps a bounded local cache, lays out working files, watches the filesystem and provides an ergonomic interface — it computes little on its own but needs far less data locally.
• A comprehensive source-control service powers many applications. Every source-control query the client uses is also exposed via API, so CI jobs and tools often need no local repository at all. Automated bisect and revert pipelines, Anthropic says, "wouldn't be practical at scale without this cheap, programmatic access."

Anthropic credits prior art: Google's Piper and Meta's Sapling — both large-monorepo systems — and says Scion was built with their hard-won lessons in mind. The post is candid that this is a niche workload today: "While we don't expect many organizations to have these problems in the very near term, we suspect it won't too long before others who use AI coding tools experience these same pressure points."

The build itself is the story

Seven engineers built Scion, Antique, code search, the IAM system and the large-code landing tooling in five months — with Claude doing much of the writing. The post frames this as a case study in the thesis it opens with: "coding is no longer the bottleneck to building systems or doing research… The bottleneck, now, is all of the developer infrastructure built for human scale: source control, builds, and CI." Claude's ability to write code created the problem and also built the solution.

What this means for you

• If your team is not merging 30,000 changes a day: nothing changes. Git remains the right default; Anthropic says so explicitly and points to Piper and Sapling as the established prior art for huge monorepos.
• If you are scaling agentic coding: watch the signals — checkout volume, mirror sprawl, seed staleness, diff/blame degradation on partial clones. Those are the early symptoms Anthropic hit before it redesign.
• If you build agent tooling: the "clients are always online" reframe is the transferable idea. Agent workloads are server-centric; designing your source control, builds and CI around that, rather than around offline human workflows, may matter sooner than you think.
• Do not expect to install Scion: Anthropic describes an internal system and an intent to "partner with GitHub, GitLab, and the OSS community," not a public release. The lesson is architectural, not a download.

Bottom line: Anthropic did not replace Git because Git is bad — it replaced Git because agent-scale merge volume broke assumptions Git was never designed around. Most teams will never need Scion, but the "always-online client" reframe is a preview of where agentic development tooling is heading, and the five-month, seven-engineer build is a concrete datapoint on how fast that future is arriving.

Prices and benchmark figures are standard published rates as of October 14, 2026 and can change without notice. Some outbound links may be affiliate links — see our disclosure. Found an error? Tell us and we'll correct it in public.