When agents write most of the commits

Anthropic has outgrown git for its own monorepo, and a team of agents built a working C compiler. The tools around software were designed for human pace, and it is starting to show.

Version control, code review and continuous integration all grew up around a simple assumption: people write the code, at the speed people write. Three pieces of engineering writing from Anthropic this year show what happens when that assumption stops holding.

Source control for agents that never log off

In October, Anthropic explained that it had outgrown git for its huge monorepo and built its own replacement, called Scion, designed around AI agents that are always online. It reports lower infrastructure costs and faster checkouts, and is sharing the ideas so that git platforms can adopt similar server-side designs.

A compiler built by a team of agents

Earlier in the year, Anthropic researcher Nicholas Carlini set several Claude instances working in parallel on one shared codebase, without a person supervising. The result was a C compiler of roughly 100,000 lines, written in Rust, that can build the Linux 6.9 kernel. The write-up is just as clear about the gaps: the compiler still leans on GCC for 16-bit x86 code, and its output is inefficient. Impressive and unfinished at the same time, which is a fair description of where autonomous development is.

Builders and critics

A third piece, on harness design for long-running application work, describes splitting the job between an agent that builds and a separate agent that evaluates, with structured planning and handoffs between them. That arrangement kept runs going for hours and produced better front-end design and complete full-stack applications. The authors add an important caution: every part of a harness encodes an assumption about what the model cannot yet do alone, so each part should be tested, and removed as models improve.

What it means for your codebase

• Expect more change, faster. Repositories, pipelines and review processes sized for a few developers will strain under agent-scale activity.
• Make tests the contract. When more code is written without a person watching each line, automated checks are what keep quality honest.
• Separate building from judging. Whether the reviewer is a person or another agent, whoever writes the code should not be the only one who checks it.
• Own your repository. If agents are going to work on your product, the code, its history and its pipelines should live in an account you control.

We build every project on a repository the client owns, partly for this reason. The tooling is changing quickly, and you want to be free to bring whatever comes next to your own code.