Did Seven People Replace Git in Five Months? What Anthropic's Internal Numbers Really Mean

Anthropic says seven people built Scion, an internal source-control system, plus its Antique code-review tool and several related services, then migrated the company’s monorepo in five months. That sounds like a tiny team replacing Git almost overnight. The more accurate conclusion is both narrower and more interesting: Anthropic redesigned source control for a highly unusual environment where AI agents generate changes at a scale that conventional developer infrastructure was not built to absorb.

Scion is not an open-source Git competitor that ordinary teams can install. It is a centralized, always-online system tied to Anthropic’s enormous monorepo, internal review stack, cloud architecture, and unusually high AI-compute budget. The internal numbers are still worth examining because they reveal where the bottleneck moves when code generation becomes cheap.

Why Git became the bottleneck

Anthropic reports that daily merged changes rose from roughly 2,500 in May 2026 to more than 30,000 by September. Its main-branch history approached 100 GB, a compressed working copy exceeded 25 GB, and CI performed about 25 million checkouts a day before counting developer environments, agent sandboxes, and research jobs.

The company had already used familiar large-repository techniques: shallow and sparse checkouts, mirrors, and snapshots stored in blob storage. At peak, it operated several hundred internal Git mirrors. Those measures bought time, but the rising merge rate made mirrors harder to keep current and made history-dependent operations such as blame and diff increasingly expensive.

The key design observation was that Anthropic’s dominant clients were no longer laptops expected to work offline. They were agents and automated jobs that were online by definition. Git’s strength—each client can hold a self-contained repository and perform substantial work locally—became expensive at Anthropic’s scale.

What Scion changes

Scion adopts an asymmetric client-server design. The server creates commits, performs merges and rebases, and answers history queries. Clients retain a bounded cache and materialize only the files they need. Many automated jobs can ask an API for a diff, merge base, or blame result without creating a working copy at all.

Instead of Git packfiles, Scion stores incremental changesets and content-addressed file data. Derived structures handle history, blame, and commit-graph queries. The service is horizontally scalable, and its sparse or virtualized working copies fetch objects on demand.

That architecture sacrifices some of Git’s distributed and offline properties. It makes sense when the authoritative repository is centralized, clients are continuously connected, and the company controls the full development environment. It would be a poor trade for many open-source projects, disconnected teams, or organizations that value portable local history.

The internal performance claims

Anthropic says Scion’s infrastructure uses roughly 200 times less CPU and memory than its previous Git-mirroring fleet. It reports that CI and research checkouts fell from minutes to seconds and that CI alone recovered 25% of CPU capacity. Each cache tier reportedly maintains a hit rate above 99%.

Those are large improvements, but they are internal measurements against Anthropic’s previous architecture. They do not mean Scion is “200 times better than Git” for a normal repository. The baseline included hundreds of mirrors serving a nearly 100 GB history and tens of millions of daily checkouts. Most teams do not have that workload, and many would never recover the cost of rebuilding their entire source-control, code-review, search, and CI stack.

The five-month schedule also needs context. A seven-person team built Scion and Antique with heavy use of internal Claude models, but the work benefited from Anthropic’s existing infrastructure, prior art from systems such as Google’s Piper and Meta’s Sapling, and direct access to the organization experiencing the problem. This was not seven people independently recreating every Git feature.

What the project says about AI coding

The most important shift is not that AI eliminated engineers. It changed their work. Anthropic describes engineers spending less time writing every line and more time specifying intent, identifying constraints, reviewing system behavior, and validating consequential changes.

That does not remove the need for judgment. A source-control platform sits on the critical path for every developer and automated job. It must preserve data, enforce access controls, survive partial failures, and recover from bad changes. Producing code faster increases the amount of behavior that must be tested and understood.

Anthropic says it used extensive simulations, fuzzing, rate limits, and directory-level permissions. Those controls are as important as the coding speed. A rapidly generated infrastructure component without strong validation would simply move the bottleneck from implementation to incidents.

Should other companies replace Git?

For almost every team, no. Anthropic explicitly says Scion is not a suitable general-purpose replacement. Its assumptions fit truly huge monorepos with thousands of contributors or swarms of agents, where clients remain online and a centralized service can answer repository questions cheaply.

The transferable lesson is to measure the new bottleneck. Teams adopting coding agents should track merge-queue delay, CI utilization, review time, conflict rate, test flakiness, and rollback frequency. If code output rises tenfold while review and deployment capacity remain fixed, developer productivity may not improve at all.

Before rebuilding source control, most organizations should optimize the surrounding system: smaller changes, incremental tests, better caching, parallel CI, ownership rules, automated risk classification, and post-merge verification. Specialized infrastructure becomes rational only after the workload proves that standard tools and simpler mitigations cannot keep up.

Verdict

Seven people did build and migrate an ambitious internal source-control stack in five months. That is a meaningful example of AI-accelerated engineering. It is not evidence that Git is obsolete or that any seven-person team can reproduce the result.

Scion’s real message is that abundant code generation pushes scarcity downstream. When agents can propose thousands of changes, the valuable systems are the ones that merge, test, review, secure, and deploy them without losing control.