Anthropic Abandons Git Internally? Building Scion to Reinvent Source Control

According to discussions in the Reddit community, Anthropic is internally advancing a project called Scion, with the goal of replacing Git as the underlying foundation of its source control system. Sources say Scion is already in use across multiple teams within Anthropic and is not an experimental project.

Why Would Anthropic Want to Replace Git?

Git was born in 2005, designed for Linux kernel development. Twenty years later, it has become the de facto standard for software development worldwide. But AI companies' R&D models differ fundamentally from traditional software teams in several ways:

• The need to review large-scale AI-generated code: When models like Claude participate in code generation, the frequency and volume of code commits far exceed what human engineers produce manually. Traditional Git's diff review process easily becomes a bottleneck in this scenario.
• Branch management for multi-Agent parallel work: AI Agents can simultaneously execute tasks on different branches. The number of branches may be an order of magnitude higher than in traditional teams, and the way merge conflicts are handled needs to be rethought.
• Tracking the association between training data and code: For a model company like Anthropic, the code repository itself may have complex dependencies with the training data pipeline and evaluation processes.

Do these scenarios really require replacing Git, or can an abstraction layer be built on top of Git? This is the question the outside world cares about most. Anthropic has not publicly explained the technical details of this decision.

Git's core design constraints: To understand the discussion about replacing Git, one must first clarify several design premises of Git. Git has a directed acyclic graph (DAG) structure. Commit objects are identified by SHA-1 (now gradually transitioning to SHA-256) hashes, and branches are essentially just mutable pointers to a certain commit. This model is highly optimized for the workflow of "human engineers working on feature branches and merging periodically," but it is not friendly to high-frequency, small-granularity, machine-generated changes—a large number of short-lived branches will cause reference counts to explode, and the snapshot-based full tracking approach also lacks native expressive capability for function-level traceability.

The design trade-offs of Jujutsu and Sapling: The two emerging VCSs mentioned in the article each have different emphases. Jujutsu (jj), led by Google engineers, has core innovations such as "the working copy is a commit" and automatic rebase, making branch management transparent to users. Sapling, developed by Meta, initially served its ultra-large-scale Monorepo and emphasizes scalability and native support for Stacked Diff. Neither abandons Git's object model; instead, they rebuild the interaction layer on top of it, which forms a contrast with the "inherit and reinvent" path Scion may take.

What Scion Might Be

Inferring from the name and available information, Scion (originally meaning "descendant/sciion") suggests that it is not built entirely from scratch, but may be some kind of inheritance and reinvention of existing version control ideas. Several reasonable guesses:

API-first design for Agents. Git's CLI interaction model is optimized for human terminal operations. If the source control system takes the API as its core interface from the beginning, AI Agents can directly read and write repository state in a structured way, reducing the overhead of parsing text output.

Built-in code review and policy engine. More deeply coupling CI/CD, code review, and permission control into the version control layer, rather than relying on external platforms such as GitHub/GitLab.

Finer-grained change tracking. Git tracks changes at the file level as the basic unit, while AI-assisted development may require function-level or even expression-level change traceability.

These are all speculations. Anthropic has not yet released a technical whitepaper or open-source plan for Scion.

The coupling between Monorepo and AI training pipelines: For a model company like Anthropic, the code repository is not just a collaboration tool; it is also directly associated with training data versions, evaluation scripts, prompt templates, and model configuration files. When a code commit may trigger re-evaluation or a data snapshot, the version control system needs to be aware not only of file differences, but also of the propagation paths of these downstream dependencies. This is the technical background behind Scion being described as motivated by "tracking the association between training data and code," and it is also a scenario that traditional Git can hardly cover elegantly using only hooks and external CI.

The practical meaning of API-first: Although Git also has libraries such as libgit2 and JGit, its official toolchain is still primarily CLI-based, and machine calls often require parsing text output. API-first means repository state is exposed through structured interfaces, and Agents can directly query the commit graph, diffs, and policy results without launching subprocesses. This can significantly reduce coordination overhead in multi-Agent concurrent scenarios, but it also means interoperability with the existing Git ecosystem becomes an engineering problem that must be solved.

Implications for Developers

Even if Scion is never released externally, its existence itself sends several signals:

1. The AI-native development toolchain is penetrating from the application layer to the infrastructure layer. Over the past two years, innovation has been concentrated at the level of coding assistants such as Copilot and Cursor. The next wave may appear in lower-level infrastructure such as version control, CI/CD, and code review.
2. Discussion of Git alternatives is becoming active again. In addition to Scion, next-generation VCS tools such as Jujutsu (jj) and Sapling are also exploring different design trade-offs. Anthropic's choice will provide important practical reference for this field.
3. The spillover effects of internal tools. Anthropic has previously open-sourced internal projects such as MCP (Model Context Protocol). Whether Scion will follow a similar path depends on the trade-off between its generality and competitive moat.

Questions Still to Be Answered

Currently, information about Scion is extremely limited, and several key questions have no answers: Is it compatible with the Git protocol? How will existing repositories be migrated? Will it be open source or closed source? What is its relationship with Anthropic's Claude Code product line?

What is certain is that a leading AI lab making such a fundamental change in its core R&D process deserves continued attention. This is not only an engineering decision, but also a window for observing how AI in turn reshapes the way software is developed.

One-line Summary

Anthropic is internally advancing the Scion project to replace Git with a self-developed system, reflecting the penetration of AI-native development tools into the infrastructure layer.

Paragraph Summary

According to discussions in the Reddit community, Anthropic is internally advancing a project called Scion, with the goal of replacing Git with a self-developed source control system. Sources say Scion is already in use across multiple teams and is not an experimental project. The article analyzes that its motivations may include the need for large-scale review of AI-generated code, multi-Agent parallel branch management, and tracking the association between training data and code. Scion's name suggests that it is not built from scratch and may adopt directions such as API-first design, a built-in review policy engine, and finer-grained change tracking. Although technical details have not yet been made public, this move is seen as a signal that AI-native development tools are penetrating from the application layer into infrastructure such as version control, and it also provides an important practical reference for discussions of Git alternatives.