Sulat.com / Writing on AIFriday, November 20, 2026
Developer Tools/19 November 2026

Bergmann: four Rust rewrites of Composer exist, but who will maintain them in fifteen years?

PHPUnit creator Sebastian Bergmann counts at least four Rust rewrites of Composer and says the question to ask is who will maintain one in fifteen years. He lists eight questions to ask before depending on a tool.

3D white disposable fork and spoon beside a sealed package box with a rust-orange gear stamp

At a glance

  • Sebastian Bergmann counts at least four rewrites of Composer in Rust and says the first question is who will maintain one in fifteen years.
  • A 2019 study of 1,932 popular GitHub projects found 57% had a bus factor of one and 25% a bus factor of two.
  • He says a dependency is a promise, and agents have cheapened writing code but not the commitment to keep it.
  • His checklist has eight questions, none about how the code was written.

PHPUnit creator Sebastian Bergmann says there are now at least four rewrites of Composer in Rust, and that the first question to ask about any of them isn’t whether it’s fast or even correct. It’s who will still maintain it in fifteen years. He makes the case in “Cheap to write, expensive to depend on”, published on 18 November on phpunit.expert.

Writing was never the expensive part

Bergmann uses Composer’s own history as the example. Work began in February 2011, and Composer 1.0 arrived five years after the first commit. Since then it has taken more than 13,000 commits from over 1,000 contributors. Packagist.org grew from one personal server into a highly available setup with mirrors around the world, and Private Packagist, the company the two founders started, has covered most of the running costs for ten years. The team is now just over ten people, and much of their 2026 work is supply chain security.

Composer also started with a bus factor of one. In July 2011, Jordi Boggiano wrote that the dependency solver still had a bug and that Nils Adermann was the only person who knew that code. That’s how most projects start, he says, so a single maintainer doesn’t rule a project out. What counts is whether other people come to understand the code, whether someone pays for the work, and whether the project keeps its promises.

A dependency costs far more to maintain over its lifetime than it did to write, in his telling: bug fixes, security responses, compatibility with new PHP versions, questions and reviews. Agents have made the first draft cheap. They haven’t made fifteen years of commitment any cheaper. He points to Daniel Stenberg’s post on two Rust rewrites of curl, which counts more than 300 commits merged into curl during the three-odd weeks agents took to convert its C code. A little over 200 of those were bug fixes that neither rewrite has.

Disposable is fine, for you

Bergmann isn’t against fast or agent-built software. Robin Sloan’s family messaging app has four users and will never have more, and Bergmann calls that a good thing: if you have an agent build a tool for your own project, you’re its only user, and you can fix it, regenerate it or bin it.

The trouble starts when that software is published as a dependency. In his words, a dependency is a promise from its maintainers to its users: bugs get fixed, security problems get handled, the next PHP version gets supported, and a breaking change comes with a new major version and a migration path. Whoever publishes a package makes that promise implicitly, and whoever installs it relies on it.

Projects die when their people move on

He cites a 2019 study of 1,932 popular GitHub projects. It found 57% 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, and only 41% of those projects survived, usually because one new developer took over.

Bars: 57% bus factor one, 25% bus factor two, 16% lost every key developer, 41% of those survived
Most popular projects hang on one or two people, and few survive losing them all. Source: 2019 study of 1,932 GitHub projects.

A rewrite whose initiator handed the implementation to an agent has a bigger problem. When that person moves on, no knowledge leaves with them, because it never existed in a human head. A successor inherits the code and, with luck, the tests, but nobody who can explain why the code looks the way it does.

“Then the agent will maintain it” is only half an answer, Bergmann says. An agent keeps working only while someone directs it, reviews its output and pays the bill, and a personal subscription is a fragile foundation for something other people depend on. An agent also can’t be accountable: it doesn’t receive the security report or put its name on a release. He adds that from December 2027 the EU’s Cyber Resilience Act requires manufacturers to exercise due diligence when they integrate third-party components, open-source ones included.

He doesn’t say agents are the problem. He trusts PHPStan’s native extension, whose repository contains instructions for coding agents, because of who stands behind it: a maintainer responsible for PHPStan for about a decade, a PHP reference implementation, a version gate, and a rule that native code which can’t prove its worth gets reverted. The economics of starting are what changed. Four Composer rewrites in Rust split their potential users four ways, and with them the pool of people who might one day take over.

Eight questions, none about how the code was written

Bergmann ends with the checklist he uses before relying on a tool:

  1. Who maintains it, and how many of them understand the code?
  2. Who pays for it?
  3. What does it promise, including a versioning policy and a security policy?
  4. How is it verified, by a reference implementation, a parity harness or an independent test suite?
  5. What does it leave out? One of the Rust rewrites says in its README that supporting Composer plugins is architecturally impossible without embedding a PHP interpreter.
  6. How are releases made, and do they come with provenance you can verify?
  7. Can you get out again? A rewrite that reads and writes composer.json and composer.lock is a cheap bet, while one with formats of its own is an expensive one.
  8. How old is it? Age decides nothing alone, but most abandonments happen early.
Checklist of eight dependency questions: maintainer, funding, promises, verification, gaps, releases, exit, age
Bergmann’s checklist for depending on any tool, and none of it asks who or what wrote the code. Source: phpunit.expert.

Bergmann’s reply: more than four, and no exemption for funded teams

I asked Bergmann which four rewrites he counted. He said he wrote the essay a couple of weeks ago and didn’t keep a list, but a search on 19 November turned up at least eight Composer-compatible package managers written in Rust: komposer, vivacity, Shirabe, Riff, PHPox (an all-in-one PHP distribution that includes one), Libretto, composer-rs and phpp. “‘At least four’ was, if anything, conservative,” he told me.

I also asked whether the checklist changes when a company or paid team is behind a rewrite. “No. The questions stay the same no matter who is behind a project,” he replied. “A company or a paid team may be the answer to some of them, but it is not a reason to skip them. Trust has to be earned.” Asked where he draws the line between an agent-written tool for your own use and one that shouldn’t be published as a dependency, he turned the question around: rather than draw a line for authors, he wants to encourage developers to review a potential dependency before they depend on it.

His advice to anyone who started such a rewrite is to find a second maintainer, write down what they promise, make the tests specify the behaviour and find someone to pay for the work. “That is the expensive part,” he writes, “and no agent will do it for you.”


Discover more from Sulat AI & Tech News

Subscribe to get the latest posts sent to your email.