In Which of your tests would survive a rewrite?, I looked at how the Rust port of 37signals' Campfire was verified. That article asked whether a rewrite is correct. This one asks a different question: can you depend on it?
Coding agents have made reimplementation cheap. Agents ported Campfire from Rails to Rust in about a day. In the PHP ecosystem alone, I count at least four projects that reimplement Composer in Rust. The README of one of them stated that it was built with a lot of help from two large language models. New test runners, frameworks, and even language runtimes appear at a pace that would have been unthinkable a few years ago.
When I look at such a project, my first question is not whether it is fast, or even whether it is correct. It is whether it will still be maintained in five years, or in fifteen. Composer and Packagist have been around for fifteen years, and I have been maintaining PHPUnit since 2000. Will the rewrite be around that long? And what happens to the projects that depend on it if it is not?
Writing was never the expensive part
Composer is a good illustration of what it takes for a tool to last. Work on it began in February 2011, and the first commit was pushed in April of that year. Composer 1.0 was released exactly five years after that first commit, by which time it had long become the standard way to manage dependencies in PHP. Composer 2.0 followed in 2020, with a rewritten dependency resolution pipeline.
None of this was a matter of writing code once. Composer has received more than 13,000 commits from over 1,000 contributors. Packagist.org grew from a single personal server into a highly available setup with mirrors around the world. For ten years, Private Packagist, the company the two founders started to make the project sustainable, has covered most of the cost of running both. The team today is just over ten people, and in 2026 much of their work is supply chain security: malware detection, immutable releases, and responding to attacks in the middle of the night.
The interesting part is how Composer started. In July 2011, Jordi Boggiano wrote that the dependency solver still had a bug and that Nils Adermann was the only one who knew that code. In today's terms, Composer had a bus factor of one. That is how most projects start, including the ones that later carry an ecosystem. Being new and having a single maintainer does not disqualify a project. What matters is what happens next: whether other people come to understand the code, whether someone pays for the work, and whether the project makes promises and keeps them.
This is what I mean when I say that writing was never the expensive part. Over its lifetime, a dependency costs far more to maintain than it ever cost to write: bug fixes, security responses, compatibility with new versions of PHP and of everything around it, answering questions, reviewing contributions, keeping a release process trustworthy. Coding agents have made the initial writing dramatically cheaper. They have not made a commitment to do all of the above for fifteen years any cheaper.
The day before this article was published, Daniel Stenberg wrote about two rewrites of curl in Rust, under a heading that could stand above this section: “Writing code once was never the issue”. He counted what happened in curl during the little more than three weeks that agents needed to convert its C code to Rust: more than 300 commits were merged, a little over 200 of them bug fixes that, as he notes, none of the rewrites has. He points to decades of API and ABI stability and writes of an alternative that appears today that it “might be able to do it as well, and in a few decades we will know if they could”.
Disposable is fine, for you
I do not think that software built quickly, or built by agents, is bad in itself. In 2020, Robin Sloan wrote a lovely essay about a messaging app he built for his family. It has four users, it will never have more, and it is still in use. He compares it to a home-cooked meal: software that does not need to be professional or scalable because it serves the people who made it. Clay Shirky described the same idea as situated software sixteen years earlier.
Coding agents make home-cooked software available to many more people, and that is a good thing. If you have an agent build a tool for your own project, you are its only user. When it breaks, you are the one who notices, and you can fix it, regenerate it, or throw it away. Taylor Otwell argued last year that software should be “simple and disposable and easy to change”. For the code in your own application, I agree.
The problem begins when disposable software is published as a dependency. A dependency is more than code. It is a promise from the people who maintain it to the people who use it: bugs will be fixed, security problems will be handled, the next PHP version will be supported, and a breaking change will come with a new major version and a migration path. Whoever publishes a package makes this promise implicitly, whether they mean to or not. Whoever installs it relies on that promise, whether they have checked it or not.
There is an irony in Sloan's story. He built his app because the one his family had used for years shut down. As far as he could tell, it had never made any money. Even polished, carefully designed software can turn out to be disposable from its users' point of view.
Projects die when their people move on
Projects are rarely abandoned because their code gets worse. They are abandoned because the people behind them run out of time, money, or interest. Research confirms what every maintainer knows. A study of 1,932 popular GitHub projects, published in 2019, found that 57 % of them had a bus factor of one and another 25 % a bus factor of two. In 16 % of the projects, every developer the project depended on had left, most often within the first two years. Only 41 % of those projects survived, usually because a single new developer took over.
The study also asked these new maintainers why they had stepped in. Most of them were using the project themselves. The authors suggest that taking over a project requires time, technical and social skills, and familiarity with the project's domain. One of their examples comes from the Composer ecosystem: Satis lost its core developers at the end of 2015 and found a new one about a year later.
Now consider a rewrite whose initiator delegated the implementation to agents and never needed to understand it. When that person moves on, no knowledge leaves with them, because it never existed in a human head in the first place. A successor inherits the code and, if they are lucky, the tests. Nobody can explain to them why the code is the way it is.
A recent article on heise.de argued that this matters less than it seems: the price of a language that is hard for humans to read and write is now paid by the agent, and the agent does not care. For writing, that is true. But the price is not abolished, only deferred. It falls due the moment a human has to understand the code: when a security report arrives, when the architecture has to change, when a new maintainer takes over. A language chosen for the agent's convenience is chosen against the convenience of exactly that human.
“Then the agent will maintain it” is only half an answer. An agent maintains code for as long as someone directs it, reviews what it produces, and pays for it. Paying for that out of a personal subscription is fine for an experiment and a fragile foundation for something other people depend on. Subscriptions get cancelled, prices change, and the person paying can lose interest. More importantly, an agent cannot be accountable. It does not receive the security report, decide whether a fix justifies a breaking change, or put its name on a release.
That last point matters more every year. The backdoor discovered in xz utils in 2024 showed what an overworked single maintainer means for everyone downstream. Composer's audit has reported abandoned packages since 2023, and since version 2.9, Composer can be configured to block updates to them. And from December 2027, the EU's Cyber Resilience Act requires manufacturers to exercise due diligence when they integrate third-party components into their products, open-source components included. A dependency that nobody is accountable for is no longer just a technical risk.
It is not about the agent
It would be easy to turn this into an argument against coding agents. That would miss the point.
Rewrites are nothing new, and some have been very good for their ecosystems. Composer 2.0 itself rewrote the dependency resolution pipeline. In the Python ecosystem, uv reimplemented package management in Rust and was adopted remarkably quickly. It was built by Astral, a venture-funded company with a full-time team. In March 2026, OpenAI announced an agreement to acquire Astral. The tools remain open source, but the concern that they could stagnate if their engineers are reassigned to other priorities is now voiced openly. The safety net is the permissive licence, which allows a fork. A fork, however, is only as good as the people who are willing and able to maintain it. Even a professional rewrite with a funded team raises the question of who will pay for it in ten years.
Conversely, coding agents are used in projects I would trust without hesitation. The repository of PHPStan's native extension contains instructions for coding agents. What makes that extension trustworthy is not how its code was typed. It is a maintainer who has been responsible for PHPStan for about a decade, a PHP reference implementation, a version gate, and a rule that native code which cannot prove its worth gets reverted.
So the relevant question is not whether an agent wrote the code. It is who stands behind it, and for how long.
What has changed is the economics of starting. When a rewrite costs a weekend and a subscription, many more rewrites get started. The study I quoted above found that successors are recruited from a project's users. Four Composer rewrites in Rust split their potential users four ways, and with them the pool of people who might one day take over. Abundance is not the same as choice when none of the options reaches the critical mass it needs to outlive its initiator.
None of my questions is about how the code was written
When I evaluate a new tool, framework, or library, these are the questions I ask. None of them is about how the code was written.
- Who maintains it, and how many of them understand the code? Look beyond the commit graph. Has anyone other than the initiator made substantial changes? Can the maintainers explain a design decision without asking an agent first?
- Who pays for it? A company, sponsors, an employer who allows working time, or nobody? Agent-driven maintenance adds a running cost of its own. A weekend and a subscription are a way to start a project, not a budget for maintaining it.
- What does it promise? Is there a documented versioning policy, with support periods and a deprecation process? Is there a security policy that tells you how to report a vulnerability and how advisories are published? A project that makes no promises cannot break any, and that is not a feature.
- How is it verified? Is there a reference implementation, a parity harness, or a test suite that specifies behaviour independently of the implementation? I have written about this in detail in the previous article.
- What does it leave out? Rewrites are usually compatible with the observable surface of the original, not with its ecosystem. One of the Composer rewrites in Rust states in its README that supporting Composer plugins is architecturally impossible without embedding a PHP interpreter. Check whether your workflows depend on the parts that are missing.
- How are releases made? This matters most for native binaries. Are releases built by automated, reproducible processes? Do they come with provenance you can verify? Who can publish a release, and how are their accounts protected?
-
Can you get out again? A rewrite that reads and writes the original's files,
composer.jsonandcomposer.lockfor instance, is a cheap bet: if it disappears, you go back. The Rust port of Campfire went as far as testing that the Rails application still works with a database the Rust application has written. A rewrite that introduces formats of its own is an expensive bet. - How old is it? Age alone decides nothing; Composer was young once, too. But most abandonments happen early. A project that has survived its first two years, and the first change of its maintainers, has shown something that a benchmark cannot show.
I am betting on the people, not the code
Coding agents have dramatically lowered the cost of writing software. They have not lowered the cost of the commitment that turns software into something other people can depend on. That commitment is made by people: people who understand the code, who are paid or otherwise able to keep working on it, and who answer when something goes wrong.
I have been releasing PHPUnit as Free Software since 2001. Very little of the code from its early years has survived; the commitment has. When I consider a new dependency, I am not betting on its code. I am betting on the people behind it.
So yes, I am sceptical of the wave of rewrites that cost their initiators a weekend. Not because an agent wrote them, but because most of them have not yet made a promise to anyone, let alone kept one. Some will. Composer once had a bus factor of one, and some of the projects that will carry the PHP ecosystem in fifteen years may well be among those started this year. Until they have shown it, I treat them as what they are: interesting, possibly excellent, and disposable.
If you started such a project, you can change that. Find a second maintainer. Write down what you promise. Make your tests specify the behaviour. Find someone who will pay for the work. That is the expensive part, and no agent will do it for you.