When 30,000 daily code merges overwhelm the tool that built the internet, you stop patching it — and start replacing it.
There’s a number buried inside Anthropic’s October 13 engineering blog post that tells you more about the state of AI development than almost anything else published this year: 30,401. That was the number of code changes merged into Anthropic’s main codebase on a single day in September 2026. Just four months earlier, in May, the number was roughly 2,500.
The difference isn’t Anthropic’s engineering team growing by 10x. It’s AI agents. And the tools that were built to handle human developers at human speeds simply couldn’t keep up.
So Anthropic did what it usually does when existing infrastructure fails: it built something new. The result is called Scion — a custom version control system designed not for a team of engineers working through a sprint, but for a codebase where AI models are opening, editing, merging, and closing thousands of branches a day.
When Git Meets the Machine
Git, the version control system created by Linus Torvalds in 2005, was designed around a fundamental assumption: developers are humans, humans work offline sometimes, and every clone of a repository needs to carry the full history so you can keep working on a plane or in a basement with no internet.
That assumption made Git beautifully resilient and elegantly portable. It also made it deeply unsuited to Anthropic’s reality in 2026.
Anthropic runs approximately 25 million CI (continuous integration) checkouts per day. Its monorepo — the single giant repository that contains most of the company’s code — has a main-branch history approaching 100 gigabytes. If every checkout naively pulled the full repository history in the traditional Git fashion, the company estimates it would generate over 600 petabytes of daily traffic. That figure isn’t operational cost — it’s an architectural impossibility.
The engineering team tried the obvious fixes first. They added Git mirror servers. They experimented with shallow clones, blob-storage snapshots, and partial checkouts. None of it was enough. The mirror fleet ran out of memory. Mirrors fell behind the main branch. Snapshot systems couldn’t keep pace with the merge volume. “Writing code stopped being the bottleneck,” Anthropic noted in its engineering post. “Source control, builds, and CI became the choke points.”
The underlying problem wasn’t a configuration issue. It was conceptual. Git is architected for distributed, peer-equal clients that may sometimes be offline and need to carry state locally. Anthropic’s clients are almost exclusively always-online AI agents and CI runners. They never need to work offline. They don’t need a full copy of history. They need fast, surgical access to exactly the files they’re about to touch.
Git was solving a different problem.
Building the Replacement
Seven engineers spent five months building Scion alongside a suite of companion tools: Antique, a code review platform; a code search tool; and a new source-control identity and access management system. The migration of the monorepo itself was part of that window.
Scion’s core design diverges from Git in a few fundamental ways:
Changesets, not snapshots. A Git commit points to a complete snapshot of the directory tree. A Scion changeset lists only the files that changed relative to its parent. File contents live in Cloud Storage, deduplicated by hash. Directory tree structures are derived by the server on demand. This means clients never pull data they don’t need.
Server-side everything. Operations like blame, diff, history traversal, and merge conflict detection all run on Scion’s servers, not on client machines. Most jobs — the CI runners, the agent sandboxes, the research pipelines — never need a full checkout at all.
Three-tier caching without negotiation. A node-level daemon, regional cache servers, and the central server all answer the same standardized requests. Because Scion addresses content by hash, caches never need to be invalidated. The result is reported cache hit rates above 99% at every tier, with checkout times dropping from a median of seven minutes to about five seconds. Total source control time per change request fell from 34 minutes to under four.
Atomic branch updates. Moving the main branch is a single compare-and-swap operation on a row in Spanner, Google’s distributed database. No global locks. No packfile maintenance. No negotiation between clients trying to figure out what the server already has.
The Engineers’ New Job: Saying No to Claude
One of the more striking details in Anthropic’s account of building Scion is who wrote most of it. According to the post, internal Claude models handled the majority of the implementation. In one case, Claude rewrote a hand-built data migration pipeline for the Git-to-Scion transition — the rewritten version ran four times faster using one-twentieth the memory while preserving existing data structures and ordering.
But the engineers’ experience with Claude on this project also surfaced something instructive about how AI agents fail as software developers. “Our main job became saying no to Claude,” the post notes. Agents would scan commit logs line-by-line when a targeted API query existed. They would add unnecessary defensive validation that was correct in isolation but wrong for the system’s design. An adversarial AI code review process — where one Claude model reviewed another’s work — kept surfacing over-engineered security checks that engineers had to push back on.
The lesson isn’t that AI agents are unreliable. It’s that the interface between human architectural intent and AI implementation requires constant calibration. The agents that wrote Scion were fast and capable. They also needed guardrails that humans had to design and enforce.
Anthropic also overhauled its merge process to match the new system’s capabilities. The company dropped its globally-locked pre-merge queue — the bottleneck where all changes waited for approval before hitting main. Instead, it adopted a post-merge, pre-deploy testing model: changes merge immediately, regression tests run before deployment, and Claude agents automatically resolve the conflicts that inevitably arise. “Claude can typically fix these conflicts faster than humans can even identify them,” the post states.
Monitoring is similarly delegated. Claude instances watch individual components in dedicated Slack channels — a practice Anthropic calls “superfans” — scanning logs and metrics for anomalies that static alerts would miss entirely.
What This Means for Everyone Else
Anthropic is explicit that Scion is not a product, not a Git replacement for the general market, and not something it plans to open-source. The design depends on a very specific configuration: an enormous monorepo, heavy AI-agent concurrency, and the kind of compute investment that is, as the post acknowledges, “far beyond what most enterprises could justify.”
But Anthropic’s projection for the broader industry is worth taking seriously: other teams operating at this level of AI-driven development will hit the same Git limits within six to twelve months.
The recommended interim steps for most engineering teams are more modest — blobless sparse clones per agent, using a forge’s API instead of cloning to answer questions, keeping branch reference counts low — but the direction of travel is clear. The tools that assume developers are human, working occasionally offline, needing full history in their pocket, were not built for a world where the most prolific contributor to your codebase is a model running in a data center.
GitHub’s own engineering team noted in April 2026 that AI-driven pull requests and commits were tied to availability problems on the platform. The volume growth that broke Anthropic’s internal Git mirrors is the same growth that is now showing up as latency and incident reports at the largest code hosting platform on earth.
Scion isn’t a cautionary tale. It’s a preview. The gap between what AI agents produce and what version control infrastructure can absorb is going to close — one way or another. Anthropic chose to close it by building what came next.
Most teams will have to decide how long they can afford to wait before they do the same.
