Generated by Codex with GPT 5.6 Sol High

The Pragmatic Engineer’s October 15 Pulse surfaced Anthropic’s original engineering account of replacing Git for its main monorepo. The striking part is not simply that Anthropic built another internal developer tool. It says AI-generated code increased the rate of change so dramatically that assumptions embedded in source control, code review, CI, and even the meaning of a working copy stopped fitting the workload.

When the repository becomes the bottleneck

Anthropic reports that its daily merged changes rose from about 2,500 in May 2026 to more than 30,000 in September. Its main-branch history was approaching 100 GB, a compressed working copy exceeded 25 GB, and CI alone performed roughly 25 million checkouts each day. Fetching every checkout naively would imply more than 600 PB of daily Git traffic.

Git has mechanisms for avoiding that worst case: shallow clones, sparse checkouts, partial clones, mirrors, and prebuilt repository snapshots. Anthropic used all of them, at one point operating several hundred internal mirrors. But snapshots fell farther behind the tip as the merge rate climbed, while operations such as history, blame, and diff became harder to preserve on partial copies. Scaling the workaround fleet also meant repeatedly materializing a repository too large for individual mirrors’ disks and memory.

The deeper mismatch was architectural. Git assumes a decentralized world in which a client may need the complete history and enough logic to work offline. Anthropic says most of its clients are now CI jobs, research processes, or coding agents that are online by definition. It therefore built Scion around the opposite premise: the server is authoritative and continuously reachable, while the client keeps only a bounded cache and the files it actually needs.

A server-side source-control model

Scion’s basic unit is a changeset in a write-ahead log. Instead of pointing to a complete repository tree as a Git commit does, a changeset records the files changed relative to its first parent and content-addressed pointers to compressed blobs. Commits, merges, and rebases happen on the server, without uploading packfiles or moving a branch ref as part of every operation. The main and release refs remain, but ordinary development avoids global pointers whose updates would require coordination across the fleet.

That compact record cannot directly answer every source-control question. Scion separately derives data structures for blame, file history, copy detection, path search, and commit-graph traversal. Each derived value is computed recursively from a changeset’s parents and can be generated eagerly or on demand. This lets Anthropic add or replace an index without changing clients, and allows tools such as automated bisect and revert pipelines to ask the service for metadata without maintaining their own repository copies.

File delivery is similarly demand-driven. The client requests immutable trees and blobs by content hash, skipping anything in its local store and never asking for directories outside a sparse checkout. On fleet machines, a node-level daemon shares cached objects across jobs. Regional cache servers answer from memory, falling back to authoritative servers backed by Spanner and cloud object storage. Every tier implements the same protocol, but traffic is deliberately constrained to the next tier so a regional-cache failure cannot stampede the authoritative service.

Anthropic reports cache hit rates above 99 percent at every tier, a 200-fold reduction in CPU and memory compared with its Git-mirror infrastructure, and checkouts that fell from minutes to seconds. It attributes a 25 percent CI CPU-capacity improvement to the migration. These figures are company-reported and do not include enough baseline or workload detail for an outside reproduction, but together they show what Scion optimizes: repeated online access to a huge, fast-changing monorepo, not the offline flexibility that makes Git useful almost everywhere else.

Agents changed the workflow as well as the volume

The same models that created the scaling problem helped build the replacement. Anthropic says seven engineers built Scion, the Antique review system, and several related services, then migrated the monorepo in five months. In one example, an early Claude Mythos Preview model rewrote a handwritten Git-to-Scion ingestion pipeline with one-quarter the runtime and one-twentieth the memory while preserving undocumented ordering and data-structure constraints.

The human role did not disappear. Team members still review every change request, but increasingly review its intent rather than every generated line. Engineers had to reject agent implementations that technically worked while violating system design—for example, linearly scanning the commit log instead of querying the review service—and to undo complexity added in response to overly hypothetical adversarial reviews. The account’s most useful engineering lesson is that faster code generation raises the value of architecture, invariant-setting, and judgment about what not to build.

Scion also embeds directory-level access control and review rules that distinguish low-risk edits from sensitive logical changes. Anthropic says it built extensive simulations, fuzzing, and rate limits, and uses model-powered monitoring agents with access to logs and telemetry alongside conventional alerts. At the same time, the merge rate has forced it away from the traditional global merge queue: when hundreds of changes can land while a test suite runs, the company relies more heavily on post-merge and pre-deployment validation, accepting that agents may have to repair concurrent conflicts afterward.

A specialized result, not the end of Git

Anthropic explicitly says Scion is not a general Git replacement and does not currently plan to release it as one. Adopting it would require replacing code review, search, CI integration, and other surrounding infrastructure, while its centralized design gives up much of Git’s offline independence. Anthropic also acknowledges that its internal token budget is unusually large, so the economics behind both the code volume and the five-month build may not transfer to ordinary companies.

The headline number—30,000 merged changes per day—also measures activity, not value, defect rate, or maintainability. Nor does a rapid internal migration independently establish that the resulting system is safer or higher quality over years of operation. What the case does establish, if Anthropic’s measurements hold, is a concrete limit of treating agentic coding as merely a faster version of human development. Once machines create and inspect changes continuously, the surrounding system has to become sparse, service-oriented, API-addressable, and explicit about authority. The bottleneck moves from typing code to governing an industrial flow of changes.