Agents Write, Agents Review: Inside Anthropic’s Software Factory
26 October, 2026
With Claude writing roughly 90% of its team’s code, Anthropic is rebuilding infrastructure and deploying multi-agent oversight. Where do humans fit in?
For decades, software development followed a fairly familiar workflow: a programmer writes code, tests it, submits it for peer review, and, once approved, merges the change into the main codebase. An entire industry of version control tools, automated testing systems, quality assurance platforms, and collaboration software grew around that process. At Anthropic, the company behind the Claude AI model, that workflow is now undergoing a fundamental transformation. The reason is simple: humans no longer write most of the code.
In two technical articles published in October, Anthropic offers a glimpse of software development when AI agents become the primary workforce. According to the company, Claude now writes roughly 90% of the code produced by the Claude Code team. The implications, however, extend far beyond saving programming time: Anthropic has had to rebuild parts of its code management infrastructure, develop multi-agent review systems, and redefine where human intervention is required.
When Code Outpaces the Infrastructure
To understand the scale of this shift, it helps to understand Git, the version control system underpinning much of modern software development. Git allows developers to work simultaneously on separate branches of a project, record changes as commits, compare versions, and merge changes once they have been reviewed and approved. One of its core principles is distributed operation: each developer can maintain a local copy of the repository, including its change history, and work independently.
That approach serves human teams well. At Anthropic, however, the pace of agent activity created an entirely different kind of workload. Between May and September 2026, daily commits to its main repository surged from roughly 2,500 to more than 30,000—a twelvefold increase in four months. That amounts to an average of more than 20 commits per minute, around the clock. Meanwhile, the Git history of the main branch grew to nearly 100 gigabytes, and testing systems needed to perform approximately 25 million code checkout operations a day.
Storage capacity was only part of the problem. Each development or testing task may require setting up a workspace, checking out a particular version, comparing files, and calculating relationships between commits. Anthropic ran hundreds of internal Git servers to handle the load, but the infrastructure became costly and cumbersome.
Its answer was Scion, a new version control system developed in-house. Unlike Git’s distributed model, in which many operations run locally, Scion operates as a centralized service. Agents and testing systems request the information they need from a server. Version calculations, comparisons, and merges can run on the server side, without requiring every task to store and process the repository’s entire history.
The system incorporates multiple caching layers, from the machine running the agent through cache servers to the central service. When thousands of tasks request the same files, those files do not have to be fetched from the source each time. According to Anthropic, the cache hit rate exceeds 99%, and the move to Scion reduced the version control infrastructure’s CPU and memory requirements by a factor of 200 compared with the previous mirror-server setup. Some checkout operations that once took minutes now take seconds.
Who Reviews the Machine’s Code?
Version control, however, was only part of the challenge. When AI agents produce code at this pace, code review can also become a bottleneck. Traditionally, a programmer submits a pull request, and another engineer examines the code for bugs, security issues, or unintended effects on existing components before deciding whether to approve it.
Anthropic developed a review system called Antique, built around several layers of AI agents. During development, the coding agent is already expected to run checks and verify that its work functions as intended. A subagent operating with a separate context can then examine the change before submission. This separation is intended to reduce the risk that the reviewer will adopt the same mistaken assumptions that caused the original error.
Once a change is submitted, it undergoes multi-agent review: several agents examine the code in parallel, looking for problems. But reviewers can make mistakes, too, so another group of agents evaluates their findings and filters out false positives. This is a particularly important safeguard: when an AI agent reports a nonexistent bug, another agent may attempt to fix it and introduce a real defect.
Alongside agent-based review, conventional software checks continue to run, including validation checks, type checking, automated tests, and security scans. Anthropic therefore combines the judgment of language models with deterministic verification mechanisms.
What remains for humans? This is where the human-in-the-loop principle comes into play: keeping people involved in oversight. Anthropic uses a risk classification mechanism to determine the level of supervision required. Low-risk changes can proceed without further human approval, medium-risk changes require approval from one engineer, and particularly sensitive changes require two human approvers. The aim is to focus human attention where it adds the most value.
According to the company, after the new review system was introduced, the share of pull requests receiving substantive review comments rose from 16% to 54%. A retrospective evaluation also found that the system could have identified roughly one-third of the bugs that had previously caused incidents on claude.ai.
Seven Engineers, Five Months, and a New Human Role
One of the most striking details is that, according to Anthropic, a team of just seven engineers developed Scion, Antique, and additional systems, completing the transition in approximately five months. The engineers themselves believe Claude already writes better code than they do for many tasks. That does not mean people have become redundant.
Their role is gradually shifting from writing lines of code to making architectural decisions, defining constraints, identifying flawed solutions, and managing risk. In one example described by the company, agents repeatedly tried to retrieve information about changes by running expensive searches through the code history, rather than using a more efficient dedicated service. The code they produced might have worked, but the engineering decision was wrong. Sometimes, as Anthropic describes it, the engineer’s most important contribution was simply telling Claude “no.”
Anthropic’s experience may offer a glimpse of software development’s future, but it does not mean every organization should replace Git or immediately adopt multi-agent review systems. Git is a mature, reliable, and flexible system, offering significant advantages in local operation, independence, and compatibility with a vast ecosystem of development tools. Scion, by contrast, was built for the unusual requirements of an organization where enormous volumes of code are generated and tested automatically, and the infrastructure remains continuously connected to the network.
Even so, the direction is clear: as AI agents write more code, the bottleneck in software development may shift from writing it to managing changes, verifying them, and ensuring their reliability. At Anthropic, the model already extends beyond programmers using AI tools. It is becoming a development system in which machines write code, other machines review it, and humans design the system, set the limits of autonomy, and remain accountable for the outcome.
Posted in: News
