Claude wrote the code so fast that Anthropic re-created the entire source system!

  It's the first time in the history of the world.

With more than 30,000 combinations of code per day, Anthropic's original development tools are no longer up to date!

On October 13, Anthropic revealed in its official engineering blog:

In May, the company combined an average of about 2,500 code changes per day; by September, that number had surpassed 30,000, more than 12 times the original.

Anthropic published daily combinations of code from January to September 2026.

To keep up with this explosive growth, a team of seven people built their own version control system Scion in just five months and moved the company's single source code library from Git in its entirety.

It is interesting to note that there is a closed circle that is supposed to be magical:

Claude wrote the code too fast to push the original tool into the bottle; he could wait for the team to rebuild the tool, solve the problem, or Claude could use it.

The problem is that Claude has to solve it.

What does "thirty thousand combinations a day" actually mean?

The software can be thought of as a book that has been revised by many people together, with some changing the first chapter, some adding the last chapter, and some responsible for unifying the entire book's terminology.

It's not the end of the world, it's the end of the world.

These changes must also be summarized to check if they contradict each other; when problems are discovered, it is necessary to know who changed where and how to go back to the previous version.

The version control system is responsible for preserving the modified records, coordinating the changes, and ensuring that the modified software can run properly after being built and tested.

As AI continues to submit modifications, the back links will also be upgraded. Otherwise, the faster the code is generated, the more tasks are waiting to be processed.

This is exactly the kind of pressure Anthropic encounters.

This isn't the first time Anthropic has rebuilt a tool for code growth.

On September 14, the company disclosed in another official article:

The continuous integration of CI missions reached 25 times the original in six months.

Continuous integration can be understood as the process of automatically constructing and verifying code after modification.

More and more tasks, responsible for judging "which tests should be run with this modification", began to lose pace.

The team first increases processing capabilities, then breaks down tasks into multiple workflows, and then tries to restart the service daily.

The duration of the three temporary remedies is as follows:

70 days, 29 days, less than a day.

It's clear that it takes less and less time to repair repairs.

In the end, an engineer rebuilt the service in three weeks.

The new architecture has higher operating costs, but is easier to expand and remains stable after optimization.

After testing the selection of service reconfiguration and optimization, the pending event volumes tend to be flat. Source: Anthropic)

The review also states that Claude tends to submit smaller, more subtle modifications and will also work at night and on weekends.

The modifications have been removed more subtly and the working time has been extended, and subsequent testing systems will naturally take on more tasks.

When you put the duplicates together, the speed at which AI writes code increases, and the pressure on subsequent links such as review, testing and merger increases.

In the face of the bottleneck of source management, Anthropic chose to build Scion itself.

One major change is that more operations are handed over to server processing, which allows customers to access data on demand.

Generally speaking, what part of the data is required for the task is taken from which part; questions that can be asked directly to the server do not have to be moved to a large amount of data for an answer.

Scion provides code data to the task on demand through layered caching.

Less data moves, less repetitions, more tasks can be carried out simultaneously.

According to Anthropic, as measured by CPU and memory requirements, Scion's infrastructure is about 1/200th the size of its previous Git mirror infrastructure.

This contrast is limited to the infrastructure used in source management and cannot be directly converted into development costs for the company as a whole.

In the process of rebuilding, Claude also brought the team an unexpected acceleration.

The team had handwritten the first prototype of a data import pipeline for Git to Scion.

Later, they had an early version of the internal Claude Mythos Preview rewritten. Officially, the rewritten version reached four times the speed of the original, with a memory capacity of about 1/20 of the original.

The growth of code brought about by AI requires tools to keep upgrading; AI's programming ability helps the team to speed up the upgrade.

This also explains why the seven-person team at Anthropic was able to complete the system construction and migration in five months.

Of course, large companies have a long history of building their own tools for super-large code libraries.

When Meta introduced Sapling in 2022, it explained how to cope with the growth of its code base and opened up Git-compatible clients.

The route has a long-term engineering build-up, with different starting points and scope for different projects, and can't just use the development cycle to compare efficiency.

Anthropic has also made it clear that Scion is aiming for a very large code library and is not a suitable alternative to Git for general use.

For most teams, the question worth thinking about is:

When AI submits more and more modifications, where will its existing processes get stuck first?

In the follow-up to the project, Anthropic highlighted one of the engineers' work:

She said "no" to Claude.

After receiving a task, the AI can come up with a plan, write out an implementation.

But a locally feasible way to integrate the whole system may add new complexity, or it may violate the original constraints.

Therefore, engineers need to judge: why was it designed this way? what conditions must be adhered to? will the time saved today become the maintenance burden of tomorrow?

These judgments are hard to come by just a few lines of code.

You may have a similar problem when you use AI as a tool.

The more functionality, the more complex the interface changes; one modification solves the problem and affects the previously normal part.

At this point, continuing to let AI add code is not necessarily going to make the results better.

Removing unnecessary needs, clarifying the relationship between functions, or even rejecting a program that has already been written is also development work.

For ordinary people, the difficulty is here too: discovering a function is not difficult, but the question is where, what part of it should be changed, whether it will affect other functions, and knowledge and experience are still needed to judge.

In this seven-person team at Anthropic, engineers also need to understand the relationships between systems, make architectural changes, and review changes submitted by AI.

More than 30,000 mergers a day make the question of "what to do after generating code" inevitable.

Judging whether AI programming is useful depends not only on how fast the code is written, but also on whether the product can't be used properly, whether the functionality meets the requirements, and whether problems can be fixed.

The next link follows, saving time by AI writing the code, so that you don't have to wait and go back to work.