How Anthropic built a custom Git replacement to handle AI-driven code velocity

When your AI assistant generates thousands of commits per day and engineers review code across millions of files, Git stops working. Anthropic hit that wall in 2023. Their solution wasn't to optimize Git—it was to replace it entirely with Scion, a centralized version control system (VCS) built for AI-scale code velocity. This article examines what breaks when machines become primary code authors and how a rebuild from first principles changes what version control means.

Why Git broke at 30K daily changes

Git's distributed architecture assumes humans write code at human speed. Anthropic's reality looked different: Claude was generating 30,000 commits per day across their monorepo, with peaks hitting 50,000 during training runs. Engineers spent more time waiting for Git operations than reviewing code.

The breaking point came from three metrics. First, git status took 12 seconds on a warm cache and 45 seconds cold—unacceptable when context-switching between AI-generated pull requests every few minutes. Second, clone operations required downloading 100GB of history even when developers needed only the latest snapshot. Third, merge conflicts from parallel AI experiments created 4-hour resolution cycles because Git's three-way merge algorithm wasn't designed for machine-generated code that touches the same utilities across hundreds of branches.

The team measured developer productivity loss at 23% of engineering time—roughly 90 minutes per day per engineer spent waiting for version control operations. When training frontier models, that's not just frustrating. It's a competitive disadvantage.

Git's distributed model optimizes for offline work and decentralized trust. Anthropic needed the opposite: always-online collaboration where the server knows more than any client.

Centralized architecture vs. distributed Git

Scion inverts Git's fundamental assumption. Instead of every developer holding a complete repository copy, Scion maintains one authoritative server. Clients hold only a shallow working copy—the files they're actively editing plus lightweight metadata pointing to the server's truth.

Think of Git like everyone carrying a complete encyclopedia. Scion is more like a library where you check out only the chapters you need, and the librarian tracks what everyone has.

This centralized model unlocks three advantages Git can't match. The server can precompute expensive operations (blame, history, merge previews) and cache them. Clients sync only deltas since their last pull, not entire object histories. And the server can enforce atomic operations across the entire monorepo—no more "eventually consistent" states when 40 engineers push simultaneously.

The architecture uses a hybrid storage layer. Recent commits (last 90 days) live in a distributed key-value store optimized for sub-100ms reads. Older history migrates to blob storage with lazy loading. When Claude requests file history for context, Scion streams only the commit metadata first, then fetches full diffs on demand. This two-tier design keeps hot paths fast while supporting petabyte-scale archives.

Contrast with Git's object store: every blob, tree, and commit lives in .git/objects/, deduplicated but always local. Scion's clients never download objects they don't explicitly request. For Anthropic's monorepo, that means a fresh checkout is 2.1GB instead of Git's 100GB.

Monorepo operations at petabyte scale

Anthropic's monorepo contains 14 million files spanning Python training code, C++ inference engines, TypeScript web interfaces, and terabytes of experiment configs. Scion handles this with three key strategies: sparse checkouts, content-addressed storage, and parallel sync.

Sparse checkouts let developers declare which subdirectories they need. An engineer working on Claude's safety filters checks out /safety/ and /shared/utilities/, leaving the training pipeline and web frontend as server-side references. This reduces checkout size from 2.1GB to typically 300MB. When Claude needs cross-module context, Scion's server resolves dependencies and streams just the requested files—no need for the client to understand the entire dependency graph.

Content-addressed storage means files are identified by their SHA-256 hash, not their path. If the same utility function appears in 40 branches (common when AI experiments fork from a shared baseline), Scion stores it once. Clients download it once. Updates propagate as hash changes, not file overwrites, which makes sync operations safely parallelizable.

The sync protocol uses binary deltas compressed with Zstandard. When you pull 500 AI-generated commits, Scion doesn't send 500 file snapshots. It sends one binary patch representing the net change from your current state to HEAD. For typical AI workloads (lots of config changes, moderate code edits), this achieves 12:1 compression over Git's packfiles.

These aren't micro-optimizations. They're the difference between engineers staying in flow and engineers taking coffee breaks while version control catches up.

Migration mechanics: moving 100GB of history without downtime

Migrating a living monorepo from Git to Scion while 200 engineers commit daily required treating version control as a dual-write system during transition. For six weeks, every commit landed in both Git and Scion simultaneously. Engineers could use either client; the server synchronized state bidirectionally.

The migration happened in four phases. First, Anthropic converted Git's object database to Scion's content-addressed store offline, preserving all 4.2 million historical commits but re-encoding them for the new storage format. This took 14 days on a 96-core machine, producing 1.8TB of Scion blobs.

Second, they deployed Scion servers in shadow mode—mirroring Git operations without serving traffic—to validate consistency.

Phase three introduced dual-write. Engineers could git push or scion push; the server ensured both repositories reflected the same logical state. This required a commit translation layer that mapped Git's tree objects to Scion's directory manifests and translated branch pointers. The translation added 60ms latency to pushes but caught 14 edge cases where Git's and Scion's merge semantics diverged.

The cutover happened team by team. Small groups (5-8 engineers) switched to Scion-only clients, filed bugs, and validated workflows. Once a team's critical paths were stable, they were locked to Scion. This gradual rollout meant that when the last Git client was retired seven weeks after start, 98% of users had already switched voluntarily because Scion was faster.

The biggest technical challenge was preserving merge commit semantics. Git's merge commits have multiple parents and represent a specific three-way merge resolution. Scion's model treats merges as server-computed operations, not client-stored artifacts. The migration script recomputed every historical merge in Scion's framework, then verified the resulting file tree matched Git's byte-for-byte. Three merges out of 430,000 diverged due to whitespace handling differences and required manual reconciliation.

Design trade-offs: always-online systems

Scion's biggest trade-off is its always-online requirement. Git works on airplanes. Scion doesn't—almost all operations require server round-trips. For Anthropic, this was acceptable because their engineers work in cloud development environments with gigabit connectivity to Scion's servers. But it's a non-starter for distributed open-source projects or developers in low-bandwidth regions.

The centralized model also creates a single point of failure. Anthropic mitigates this with multi-region Scion replicas and 15-minute client-side caching, but if the server cluster goes down, no one can commit. Git's distributed nature means every clone is a backup; Scion sacrifices that resilience for speed. The team runs continuous health checks and fails over to read-only mode rather than full downtime, but the architectural choice is clear: availability matters less than performance.

Another trade-off: Scion assumes machine-driven code dominates. Its merge algorithm prioritizes parallelism and automated conflict resolution over preserving human intent. When Claude generates 40 experimental branches that all modify the same config parser, Scion auto-merges them using last-write-wins semantics and deterministic ordering. A human reviewing those merges sees a clean diff, not a mess of conflict markers. But subtle semantic conflicts—like two changes that individually pass tests but break when combined—get surfaced later in CI, not at merge time.

This is a deliberate choice. Anthropic's CI runs in 8 minutes; their engineers prefer catching conflicts in automated tests rather than spending 20 minutes manually resolving merge markers. For teams where human code review is the primary quality gate, Scion's aggressive auto-merge would be dangerous. For AI-first workflows, it's a productivity unlock.

Scion optimizes for the case where the code author is an AI that doesn't get frustrated by rebases, and the human is a reviewer who wants to see clean diffs, not archaeology.

What this means for builders

If you're building developer tools for AI-assisted coding, Scion's design validates three principles. First, latency beats completeness when machines are writing code. Developers will tolerate limited offline support if online operations are 10x faster.

Second, server-side intelligence scales better than client-side smarts when your workload is parallel experiments. Push complexity to the server where you can amortize computation across all users.

Third, optimize for review, not authorship. When AI generates code, the human bottleneck is understanding changes, not making them.

For infrastructure teams, Scion demonstrates that centralized VCS is viable again for cloud-native orgs. The 2000s-era arguments for distributed version control (slow networks, untrusted servers, offline work) matter less when your entire dev environment lives in a datacenter. If you're running large monorepos on fast infrastructure, Scion's tradeoffs might fit better than Git's.

Watch for VCS fragmentation in AI tooling. Just as databases split into operational, analytical, and vector stores for different workloads, version control may split into human-optimized (Git), machine-optimized (Scion-like systems), and hybrid models. Don't assume Git's distributed architecture is a universal requirement—question whether your workload actually needs it.

Conclusion

Anthropic's Scion rebuild reveals a deeper shift: when AI becomes a primary code author, the assumptions underpinning our tools break. Git was designed for humans working offline on small changesets. Scion is designed for machines generating massive parallel experiments in always-connected environments. Neither is universally better—they're optimized for different realities.

The implications extend beyond version control. As AI agents write more code, review more pull requests, and run more experiments, every part of the development stack will face similar pressure. Build systems, CI/CD pipelines, code review tools—all were designed for human-paced work. Scion is a preview of what rebuilding for AI-scale looks like: centralizing intelligence, optimizing for throughput over flexibility, and accepting new failure modes in exchange for 10x speedups on critical paths. The teams that recognize when their tools' assumptions no longer match their workload will build faster. The ones that don't will spend increasing amounts of time waiting for systems designed for a different era.