After the AI code glut, companies that "flush the toilet" for code have seen their valuations surge tenfold.

Anyone who often uses AI to write code knows that it is not difficult to produce a runnable program, but if you are not careful enough, the file will inexplicably become several times larger.

I once got a sudden whim to ask AI to help me build a website. Although it was generated with just a few words, at first glance, it stubbornly output more than 2,000 lines of unmaintainable spaghetti code.

Before AI programming became popular, writing code was the most time-consuming part of software development. But AI is so powerful now that code that used to take hours or even days to complete can be generated in minutes.

However, the problem is that as the pile of code grows, the tedious work of sifting through the messy low-quality code also piles up.

AI can write hundreds of lines of code in a minute, but companies cannot directly deploy this code to millions of users just because it barely runs.

A company that specializes in "flushing the toilet" for AI-generated code has seen its valuation surge nearly ten times as a result.

On August 12, according to TechCrunch, Blacksmith, which provides continuous integration (CI) infrastructure for GitHub Actions, completed a $45 million Series B financing, with a valuation reaching $550 million. Less than a year ago, its valuation was only about $60 million.

Blacksmith does not invent smarter AI, nor does it help programmers write code. What it does is the remaining work after AI generates code: running tests, performing builds, and verifying whether these AI-generated codes can be safely integrated into real software.

It is not the testing itself that drives up its value, but the ever-increasing volume of code that needs to be processed.

Humans can no longer keep up with the volume of code written by AI

Blacksmith noticed very early on that the amount of code was becoming overwhelming.

In September 2025, when the company announced its Series A financing, it disclosed that excluding the impact of the growing number of developers, the volume of continuous integration tasks run by its existing customers increased by an average of 60% per quarter.

Blacksmith attributes this change to the explosion of AI programming tools. After all, humans only have 24 hours a day, so the amount of code they can produce is limited, and there is naturally an upper limit for subsequent testing, building and code review.

But the explosion of Coding Agents has changed this situation.

Most current programming Agents can read code repositories, modify multiple files, run tests, and then deliver the results to humans, rather than just helping programmers fill in a few lines of code. More importantly, Agents do not need to clock off or sleep, and they can schedule multiple Subagents to split a complex task into parts and handle multiple different jobs at the same time.

As a result, code production has begun to break away from the limitation of "how many programmers you have equals how many hands you have", moving from the manual workshop era to the industrial era.

Boris Cherny, head of Claude Code, already works in a way that resembles a small code factory.

In June this year, Boris Cherny said at the Fortune Brainstorm Tech conference that he had not manually written a single line of code for 8 months.

Instead, he began to manage an increasingly large team of Agents. Boris said that on the morning of the conference, he was managing "hundreds" of Agents at the same time; sometimes this number would rise to thousands, or even tens of thousands.

OpenAI also conducted a fairly extreme experiment to see how far this change could push code production.

At the end of August 2025, a team of 3 engineers at OpenAI started from a blank code base and used Codex to develop an internal software.

The rules were simple: humans did not write code directly, and all application logic, tests, CI configurations, documents, observability functions and internal tools were all generated by Codex.

Five months later, the code base had expanded to about 1 million lines, and about 1,500 Pull Requests (PRs) were completed during the period. OpenAI estimates that if all this work was done manually by humans, it would take about ten times longer.

Interestingly, OpenAI stated that they often saw a single Codex task working continuously for more than 6 hours, and in many cases, humans had gone to sleep while the Agent was still working.

The upper limit of code production has thus begun to decouple from human working hours.

But soon a new problem emerged: code is being written so fast that humans can no longer keep up.

OpenAI wrote directly in this experiment that as code throughput increased, the new bottleneck they encountered became "human QA capability".

No matter how much code an Agent can write, human time and energy are limited after all.

This team had to spend a whole day every Friday specifically cleaning up the so-called "AI slop", which refers to the unmaintainable messy code written by AI. These codes usually come from the side effects when Agents generate code quickly: such as duplicate or incorrect implementation patterns, inconsistent code styles, and technical debt that keeps accumulating in the system.

But soon, humans could not keep up with this work either.

So OpenAI handed over the "cleanup" work to Agents: letting background Codex tasks scan the code base regularly, find problems, and automatically submit refactoring PRs. Even a large number of code reviews began to be handed over to Agents to check each other, and humans only intervened when judgment was needed.

In other words, AI has begun to appear at both ends of the production line: frantically producing code on one end, and helping humans find problems in the code on the other end.

However, those tests, builds and CI tasks that must actually be run have not disappeared.

Blacksmith wrote a very straightforward sentence: If every code modification still takes an hour to test, then a Coding Agent that is 100 times faster than humans will not make much sense.

AI has not eliminated the bottleneck in software development.

It has only shifted the bottleneck from "how to write this code" to "how to verify such a large volume of code".

After AI code surplus, the company that "flushes the toilet" for code sees its value surge tenfold

To understand why Blacksmith's valuation jumped from $60 million to $550 million in less than a year, you first need to clarify the company's main business.

There is still a long way to go from the moment a piece of code is written by a programmer to when it actually appears on a user's mobile phone or computer.

For example, if you add a new payment button to a shopping website, after the code is written, you first need to confirm whether it can compile normally; then run a set of automated tests to see if the button works; then run more tests to confirm that this modification does not accidentally break the login, shopping cart or refund functions.

These tasks are usually organized into an automated pipeline: every time a programmer submits a piece of code, the machine automatically pulls the code, rebuilds the software, runs tests, and checks the results. If a problem is found, the code is sent back for modification. Only after all checks pass can the code move to the next step.

This pipeline is called Continuous Integration (CI).

GitHub's own GitHub Actions is one of the most common CI tools.

What Blacksmith actually does is the "execution layer" under this pipeline.

GitHub Actions is responsible for specifying "which tests to run and in what order", while Blacksmith provides the computing environment to actually execute these tasks.

In other words, Blacksmith does not help you write test rules, but provides machines to actually complete build, testing and deployment tasks.

Its initial selling point was very straightforward: to make GitHub Actions run faster and cheaper.

According to Blacksmith, it uses high single-core performance CPUs, local caches and NVMe storage to run these tasks. Most CI tasks can run about twice as fast as GitHub's hosted servers; some Docker builds can get even greater speedups when the cache takes effect. For developers, migration may only require modifying one line of GitHub Actions configuration.

The founder of Blacksmith later described CI as essentially "plumbing work for developers". They even joked that they wanted to make CI "sexy for once".

But AI programming has turned its most inconspicuous feature into an advantage: in the past, programmers submitted code several times a day, and CI ran accordingly; now Agents can continuously modify code, try repeatedly, and call Subagents in parallel, and every modification will trigger a new round of build, testing and verification.

Blacksmith mentioned during its Series A financing that with the development of AI code generation tools, the rapid increase in code volume is pushing CI to a new bottleneck. To this end, Blacksmith does not simply rely on general cloud computing resources, but optimizes its own hardware and software stack for CI tasks, providing faster execution speed, higher concurrency capability, and a computing environment more suitable for testing processes.

The better AI becomes at writing code, the more machines Blacksmith needs to run. This "dirty work" that used to be hidden in the background of software development has thus been amplified by AI.

In September 2025, Blacksmith served about 800 organizations; less than a year later, this number has grown to more than 5,000.

The number of employees in the company increased from about 10 to around 30, and its annualized revenue rose from $10 million to the "tens of millions of dollars" range. According to TechCrunch, some of the largest customers now spend more than $1 million per year on Blacksmith.

Today's Blacksmith is no longer satisfied with only being a faster CI execution layer, and it has begun to integrate AI capabilities on top of its business.

For example, Codesmith can read code repositories, modify code and create PRs, and also assist in locating and fixing problems based on CI failure information; Test Analytics is responsible for sorting out test failure information; Testboxes will create a temporary virtual test environment for Agents to run the newly modified code, and if it fails, the result will be sent back to the Agent for further modification.

A new software production line is emerging: Agents write code, Blacksmith runs tests; if the test fails, AI summarizes the problem; Codesmith modifies the code and sends it back to Testbox for retesting.

As a result, both code production and code verification are becoming increasingly automated and Agent-driven.

But there is a key difference here.

AI can find bugs and modify code on its own, but the final confirmation that "this piece of code really works" cannot be determined by AI itself, and the code must actually be run.

As long as the code is actually run, it will consume real computing resources. Models can keep lowering the marginal cost of writing code, but servers will not skip a test just because the code is written by AI, nor will they offer discounts for high volumes.

What Blacksmith earns is essentially the last sum of unavoidable costs.

The end point of AI code writing is a larger acceptance industry

In fact, over the past year, almost all major AI companies have begun to move to the second half of the code production line.

When Codex was first launched, OpenAI specifically reminded users that even if Agents could already modify code and run tests on their own, AI-generated code still required manual review and verification before actual integration and execution.

But soon, Codex itself began to do reviews. In September 2025, OpenAI disclosed that Codex had reviewed the vast majority of PRs within the company, and could find hundreds of problems every day, many of which were identified before humans even started the review process.

Anthropic is also doing similar things.

Claude Code added automatic security review capabilities in March this year, which can directly check for SQL injection, cross-site scripting (XSS), authentication vulnerabilities, insecure data processing and dependency vulnerabilities in PRs, and run automatically through GitHub Actions.

But Anthropic also emphasized at the same time that this set of functions cannot replace existing security processes and manual reviews.