Agents
Anthropic Ditched Git After Claude Hit 30,000 Merges a Day
Oct 14, 2026·5 min read·By Rahish Saifi
On October 13, 2026, Anthropic’s engineering team published a detailed account of how it redesigned source control for an era in which Claude—not human typing speed—sets the pace of software change. The company built Scion, an in-house version control system, and fully migrated its monorepo off git in five months. The trigger was blunt: as Claude-driven merges accelerated, git-backed infrastructure became Anthropic’s biggest development bottleneck.
Coding is no longer the limit on building systems or doing research inside the lab; the friction moved to infrastructure built for human scale—source control, builds, and CI.
Key facts at a glance
- Merge volume: ~2,500 code changes merged per day in May 2026; over 30,000 per day as of September 2026 (Anthropic engineering post).
- Migration: Monorepo fully migrated from git in five months; a seven-person team built Scion and Antique (code review) plus half a dozen related systems; Anthropic also shipped code search and a source control IAM system in the same period.
- Repo scale: Main-branch history alone is almost 100 GB; a compressed working copy is over 25 GB; ~25 million CI checkouts per day (naive fetch would be over 600 PB of git traffic daily).
- Architecture: Server-centric, always-online clients; commits, rebases, and merges on the server; metadata in Spanner; tiered scion-daemon, regional scion-cache, and scion-servers with >99% cache hit rate per tier.
- Outcomes: Scion infrastructure 200× smaller in CPU/memory vs. prior git mirroring; CI/research checkouts two orders of magnitude faster (seconds vs. minutes); CI gained a 25% CPU capacity win.
- Not shipping: Scion is not a general git replacement and is not being released; Anthropic wants to partner with GitHub, GitLab, and the OSS community.
What happened
In the post titled “Redesigning source control at Anthropic”, Nick G. and the source control team explain that merges per day grew more than tenfold, and source control became the primary choke point. Anthropic had already leaned on shallow clones, sparse checkouts, promisor remotes, internal git mirrors, and blob-storage “seeds”—at peak, several hundred internal mirrors—but merge rate growth made that stack harder to operate.
The team’s reframing: Anthropic was effectively using git as a centralized system with one authoritative copy, while nearly all clients were agents and jobs that are online by definition. Offline-first git strengths became scaling liabilities. Scion is the answer they built in-house—alongside Antique and supporting tooling—in the same five-month window as the full migration.
The numbers behind the git wall
The post’s scale figures are the reason the migration reads as inevitable rather than optional. Beyond merge counts, Anthropic cites main-line history approaching 100 GB, working copies above 25 GB compressed, and on the order of 25 million code checkouts per day for CI alone—before developer environments, agent sandboxes, and research jobs. Fetched naively, that checkout volume would imply over 600 petabytes of git traffic daily.
Anthropic says it does not expect merge growth to slow—the latent demand for merging code is practically infinite, and removing one bottleneck immediately increases code production.
How Scion works vs. git
Scion deliberately breaks git’s symmetry. Principles from the post include: clients are always online; strong client-server asymmetry (the server answers history/blame questions, creates commits, and performs merges and rebases); horizontal scalability with no fully materialized repo copy anywhere; cheap, incremental, lock-free server-side changesets whose cost scales with the change, not the whole repo; and sparse or virtualized working copies so CI can often skip disk checkouts entirely.
Data is organized as server-side changesets in a write-ahead log—similar to commits but storing changed files relative to a first parent, with content-addressed blobs. Additional derived data (blame, path history, graph skip lists) is computed through one generic mechanism. Refs exist but are discouraged except for main and release branches, because global ref state is a scaling hazard.
Operationally, a node runs scion-daemon with regional scion-cache servers and authoritative scion-servers backed by Spanner and cloud storage. Fetch negotiation requests specific immutable trees and blobs—no multi-gigabyte packfiles—so the stack behaves like tiered caches. Anthropic reports over 99% hit rates per tier and a footprint 200 times smaller in CPU and memory than its git mirroring fleet.
What Claude did in the loop
Anthropic is explicit that Claude both created the crisis and accelerated the response. Internal releases including Claude Mythos Preview and Claude Tag arrived as Scion work began, amplifying demand and build speed. One example: an early handwritten git-to-Scion ingestion pipeline was rewritten by an internal Mythos snapshot with no further instructions, yielding 20× less memory and 4× faster execution while preserving ingestion invariants.
Engineers still steered design—Anthropic says they often told Claude “no” when agents violated core constraints or over-engineered around adversarial review. The team also uses Claude “superfans” in Slack channels obsessively monitoring components (scion-daemon, scion-cache, Antique merge queue, and others) against telemetry. On process, they haven’t been able to effectively replicate the industry-standard global repository lock on the merge queue; instead, they invest in post-merge and pre-deploy testing, accepting concurrent conflicts Claude can usually fix quickly.
Why it matters if you use AI coding agents (analysis)
Analysis: Most teams will not run a 25 GB monorepo or thirty-thousand merges a day next quarter. Anthropic says as much. But the post still matters for three reasons.
First, it quantifies a feedback loop many companies are only beginning to feel: agent throughput converts into CI checkout storms, review queue depth, and merge contention long before “the model” feels slow. Second, the design choices—server-side commits, API-first metadata queries, sparse checkouts—are portable ideas even if Scion itself is not. Anthropic explicitly hopes git platforms can adopt richer server-side RPCs and better sparse/shallow composition without abandoning git’s client model.
Third, the seven-person, five-month delivery story is a template for how agent-assisted engineering teams may ship infrastructure: humans own intent, boundaries, and tradeoffs; agents supply volume, tests, and optimization passes. If your roadmap assumes “we’ll scale git mirrors forever,” Anthropic’s numbers are a useful stress test.
What Scion is not
Anthropic stresses that Scion is by no means a suitable replacement for git for general use. It targets enormous monorepos with huge engineer or agent swarms, depends on bespoke review/search/CI surfaces, and reflects Anthropic’s unusual ability to spend tokens internally. Practically, releasing Scion would require every organization to migrate the whole development lifecycle—not just swap a remote URL.
The company’s stated path forward is sharing lessons, not shipping a product: partner with GitHub, GitLab, and open-source maintainers so the wider ecosystem can absorb agent-scale pressure without every company facing similar challenges alone.