Blog
Software Preppers: Dependencies After the Commons
Code is getting cheap. The agreement that makes it useful is not
I. The Bunker in the Basement
The software commons is not going to collapse in a day. It is going to get thinner, one archived repo at a time, until every team with an AI agent has quietly become its own maintainer of everything. This post asks what happens then, and what the minimum is that you still cannot own.
Picture the prepper. Basement full of rice, a water filter, a generator, a shelf of seeds. He has thought hard about what he can make himself. Then he gets an infected tooth, and the whole fantasy meets its limit: you can grow food, but you cannot make antibiotics. Self-sufficiency always has a floor, and the floor is made of things that only a functioning society produces.
The point is not that the prepper should manufacture antibiotics. It is that a sensible plan separates what can be stockpiled, what can be reproduced, and what needs a functioning network of other people.
The question came to me while working on cancho, a language designed for agents to write rather than humans: if I owned the language, the compiler and the libraries, what would I still depend on? I am not alone in asking it. Developers who tell their agent to rewrite the YAML parser rather than import it, or who vendor everything, are running smaller versions of the same experiment every day.
You can fork an implementation, and you can fork a specification, but you cannot unilaterally fork the agreement that makes either useful.
Code is becoming cheap. Agreement is not. The interesting future is not who has the biggest bunker, but who builds the best villages.
II. The Thinning Has Already Started
This is no longer purely a thought experiment. The first half of 2026 produced early signs of stress in the software commons. If this does become a collapse, these are its opening scenes, and they are less cinematic than expected.
- January. In a comment on a closed pull request, Tailwind Labs founder Adam Wathan said docs traffic was down about 40% from early 2023, revenue down close to 80%, and that three quarters of the engineering team had lost their jobs the day before. Self-reported, about one business. Usage up, income down.
- 21 January. “Vibe Coding Kills Open Source” (Koren, Békés, Hinz, Lohmann) models how agents can cut the engagement that used to pay maintainers, and concludes that sustaining open source requires major changes in how they are paid. An economic model on arXiv, not a measurement.
- 26 January. curl announced the end of its bug bounty, effective 31 January. Security reports are still accepted, without payment, which removes the cash incentive behind a flood of low-quality, often AI-generated reports (The Register). Primary announcement.
- 13 February. GitHub added repository settings that let maintainers disable pull requests or restrict them to collaborators. The platform now ships a “close the door” switch. Primary changelog.
- 16 February. Jeff Geerling: “AI is destroying Open Source, and it’s not even good yet”. How it feels from inside a maintainer’s inbox, not a measurement.
- March and April. The prepper move, endorsed by a well-known name: a newsletter relays Karpathy’s push to cut dependencies in favour of generated code, and yoink, a small Claude Code plugin, reimplements just the functions you use. Opinion and a tool.
- 20 April and 20 May. Greg Herlein, “Agentic Coding is About to Fracture Open Source”, names the fork explosion directly; LeadDev argues that AI-generated abandonware is hollowing out open source, so that scarcity shifts from code to maintainers. Opinion and prediction.
The entries are not equal evidence. Two are primary announcements, one is a company’s own figures, one is a model, and the rest are opinion. Together they show a direction, not a measured rate.
Two forces pull the same way. From the top, maintainers close their doors because agents flood them with noise. From the bottom, users stop needing the door at all, because their agent can patch a private copy faster than an upstream PR gets reviewed. Both end in the same place: many copies, no shared one.
III. Who Has Been Here Before
Most pieces of this idea have been studied, and the whole may well have been too, somewhere my searches (and my AI’s training data) didn’t reach. In the material I found, five camps each hold one part of the map:
- Commons economists (Koren et al.; Nadia Eghbal’s Roads and Bridges and Working in Public) explain why maintainers stop: engagement was the payment, and agents skip it. They treat the collapse as a funding problem and say little about what users do after it.
- Fork-explosion writers (Herlein; Tim O’Brien’s “The Fork-It-and-Forget Decade”; madewithlove) predict thousands of private, divergent copies. Their remedies are discovery tools, such as a meta-repo that would map the forks, or none at all.
- Anti-dependency builders (Karpathy, yoink, and Ding and Stevens on zero-dependency Python libraries) show that regeneration works. Two moves hide here: reimplementing from an API spec and tests, as the Commit0 benchmark does, and using the original library as a correctness oracle during development. The second quietly assumes the oracle still exists, and the oracle is the thing that is dying.
- Collapse computing (Collapse OS, the permacomputing wiki, Tomlinson’s “collapse informatics”) is the literal prepper: a system that can assemble itself and run on improvised machines. It is aimed at civilisational collapse, not a social one with the factories still running.
- Trust and bootstrapping (Ken Thompson’s “Reflections on Trusting Trust”, bootstrappable builds, Unison’s content-addressed code) show how small a trusted seed can be and how to name code by what it is. They solve trust in your own build, not agreement with strangers.
The gap this post sits in: I could not find anyone asking the prepper’s question at the scale of one developer with an agent, which probably says more about my search than about the world. If my agent can regenerate anything, what is left that I genuinely depend on, and how do ten thousand self-sufficient developers still talk to each other?
IV. Ten Thousand OpenSSLs
Take an ordinary system: a web service on Linux, Python or Node, Postgres, a TLS library, a JSON parser, a date library, a few hundred transitive packages. Now remove the upstreams and give every team an agent that maintains its own copy of each. Four things break, in roughly this order.
Coordinated vulnerability response weakens. Today a bug like Heartbleed is fixed once and shipped to everyone. Private forks will not all fix flaws independently; many will still share patches or sit downstream of a distribution. The loss is the single coordinated path. Each fork that drifts from it needs the fix found, ported and shipped again, and an attacker only needs the forks that missed it. Discovery is speeding up: HeroDevs wrote in June 2026 that curl was on track for around 50 published CVEs this year, a record. That is a vendor’s projection, not curl’s own count. More bugs found is good news when the fix reaches everyone, and bad news for every copy it does not reach.
Interop drifts. Every spec has ambiguous corners: how a parser treats duplicate JSON keys, how a date library handles a leap second, how an HTTP client folds headers. Each agent resolves them its own way, plausibly and locally. Each fork passes its own tests. The system as a whole quietly stops agreeing with itself, and the failures show up only at the boundaries between organisations.
Knowledge evaporates. A mature library is mostly scar tissue: the weird branch that exists because of one bank’s broken proxy in 2014. Regenerated code passes the obvious tests and loses the scars. Shared bug trackers were the commons’ memory; private forks have none.
Coordination loses its anchor. Supply-chain practice today leans on a canonical release you can sign, pin and audit. Canonicality is not itself a security property: one canonical release can be compromised, and many releases can still be trustworthy. What matters is whether consumers can identify the artefact, see how it was produced, verify the properties they care about and decide which claims to trust. When none of that is in place, things go wrong in odd ways: one hallucinated package name, react-codeshift, spread through forks to over 230 repositories (the source is a sponsored article, and HeroDevs counts 237).
What survives best is what already behaves like a village. Linux distributions, Nix and the big vendors already maintain patched forks of thousands of packages with shared security teams. In the collapse scenario they become the walled towns everyone moves into. The likely outcome is not anarchy but re-centralisation: open source concentrates in a few large, funded maintainers. That is not automatically the end of the commons. Institutions that maintain and fund shared infrastructure can be the commons, as long as what they maintain stays open and others can still leave.
V. The Bunker Inventory
With your own language and an agent that writes the rest, the floor is lower than most people think, but it is not zero. And it is not one floor. The boundary is not between things that can and cannot be implemented. It is between things an individual can reproduce, things they can validate independently, and things whose usefulness depends on other people recognising them.
| Layer | What you can do alone | Prepper equivalent |
|---|---|---|
| Application libraries JSON, HTTP client, dates | Small, well-specified ones, yes. Mature ones full of undocumented behaviour, much harder. Validation reaches only as far as the tests do. | Growing your own vegetables |
| Runtime and compiler toolchain standard library, clang/LLVM, a linker | A subset of a runtime and a small self-hosted compiler, yes. LLVM’s optimisation, debug info, ABI and platform coverage, no. Bootstrappable builds shrink what you must trust. | Canning, and building your own generator |
| C library and kernel ABI glibc, musl, Linux syscalls | Depends on the target: Go avoids much of libc on Linux but uses the system libc on macOS, Windows and some BSDs. The syscall interface you target, you do not reproduce. | Off-grid water, and the land the bunker sits on |
| Cryptographic primitives ChaCha20, Ed25519, SHA-2 | Reproduce: yes, with test vectors. Validate: the hard part, since side channels and misuse need expert review. | A gun you machined yourself |
| Protocols and formats TCP/IP, TLS, HTTP, DNS, Unicode, IEEE 754 | Implement: yes, and check against conformance suites where they exist. You depend on shared meaning and cannot change it alone. | The language your neighbours speak |
| Trust roots certificate authorities, DNS root, signing keys | Technically yes; anyone can run a CA. But relying parties must adopt it, and that is not up to you. | The pharmacy |
| Cloud provider rented compute | You can run your own machines, at a cost; not their hardware, operations and control plane. You accept their terms, jurisdiction and exit costs. | Renting the bunker from someone who keeps the keys |
| Hardware and firmware microcode, ISA, boot firmware | Open designs and FPGAs exist; the physical supply chain does not. Fabs and vendors decide. | Antibiotics |
Reproduction, validation and adoption are different achievements. You may reproduce an implementation without being able to establish that it is safe, and establish that it is safe without being able to make other systems recognise it.
Read that way, clang is not on the floor. It is a convenience you can replace with something smaller that you understand, at the cost of what LLVM has accumulated. The real floor is where “get others to accept it” stops being up to you: protocols, trust roots, the cloud and hardware. The cloud is the sneaky one: it looks like software because you reach it through an API, but what you depend on is someone else’s machines, staff, control plane and legal jurisdiction. Your bunker can hold every line of code you run and still be useless the day your certificate expires.
VI. What You Cannot Stockpile
Everything on the floor shares one property: its value comes from other people agreeing to it. A TLS implementation is worthless if it is correct and nobody else’s matches. A certificate authority is a promise that millions of browsers keep. Unicode is a committee decision you inherit. You can download a copy of the code; you cannot download a copy of the agreement.
This is where the prepper analogy gets sharper rather than sillier. Preppers discover that the hardest things to replace are not goods but relationships: the doctor, the mechanic, the neighbour who trades. Long-term survival stories tend to end with the bunker dweller rejoining a community, because groups outlast individuals.
Software has the same shape. There is an analogy here with gauge theory, where local descriptions can be internally consistent while comparing them requires a shared convention. Each fork chooses its own local convention, and everything is consistent inside one fork. What breaks is the comparison between forks, and you only get it back by agreeing on a shared connection, a common reference that carries meaning from one place to another. Specs, test vectors and trust roots, together with the governance that keeps people agreeing on them, are that connection. The documents can be copied; what cannot be regenerated alone is the shared recognition of what code must do.
VII. Villages, Not Bunkers
If code becomes cheap and agreement stays expensive, the unit of sharing should move from the implementation to the agreement. The library of the future may be a specification, a conformance corpus and a record of the failures that shaped them. Any agent can attempt to regenerate an implementation; the shared artefacts make it possible to judge whether that implementation behaves as expected. This does not make implementations disposable in every sense: mature ones still hold performance work, operational knowledge and security engineering that are expensive to reproduce. It changes what the commons should preserve and share.
In practice, six things for the commons to maintain:
- Conformance suites. Instead of 10,000 people maintaining 10,000 JSON parsers, a few people maintain one demanding test suite, and some scar tissue moves out of implementations and into shared tests that every fork inherits. This already works where suites exist: the WebAssembly spec test suite; JSONTestSuite, which exposed how differently JSON parsers treat the same input; and the Commit0 benchmark, which asks agents to rebuild 54 Python libraries from a spec and unit tests (at publication, in 2024, none could yet fully reproduce one). But tests preserve only the failures someone has learned to describe, and a test suite is software too: it can be incomplete, wrong or out of date.
- Shared incident knowledge. A conformance suite tells a new implementation what it must do. An incident record explains why: what failed in production, how a vulnerability was found, which workaround is load-bearing. That knowledge disappears when maintainers leave or issue trackers close, and without it agents will regenerate the documented behaviour while rediscovering the failures that taught earlier maintainers to be careful.
- Content-addressed code. Name a function by the hash of what it is, as Unison does, rather than by a package name and a version. A hash gives exact identity to an artefact under one hashing and encoding scheme. It does not prove two different implementations are equivalent, but it gives verification and patching a stable object to point at: a fix can be routed to every fork that contains the vulnerable hash.
- Structured claims, not just signatures. A signature supports identity and integrity; it does not make a claim true or an artefact good. The useful object is a structured statement: who produced the artefact, how it was built and from what, whether it has changed, what was checked against which version of which tests, and the rules by which a consumer decides which of these to accept. Herlein’s proposed meta-repo of forks would help find them; claims like these are what would make choosing one defensible.
- Small trusted seeds. Bootstrappable builds show you can rebuild a whole toolchain from a seed small enough to audit by hand. That is the right size for the kit you carry.
- Funded floors. The bottom of the stack (protocols, crypto, trust roots, conformance suites, incident records, standards work) is what public money should buy. Germany’s Sovereign Tech Agency already does some of it: it invested €152,000 in 2023 and 2024 in an ActivityPub conformance test suite, and in 2026 started a pilot that pays up to ten maintainers to take part in standards work at the IETF, W3C and ISO.
None of this is a complete answer. Specifications, tests, hashes and signatures make claims explicit and verification reusable; people and institutions still have to create, maintain and govern them. The prepper who builds a radio, not a bigger wall, is the one who makes it.
VIII. Where This Meets the Manifesto
The manifesto asked how one agent can trust code it did not write. This post asks how ten thousand forks can trust each other. They turn out to be the same argument at two scales: specifications as contracts become shared specifications and conformance corpora; stable identities for semantic units become content-addressed artefacts; attestation over review becomes structured, signed claims; effect types and capability gates become explicitly bounded authority. That last one speaks to “coordination loses its anchor”, within limits. A capability-gated fork can be safer to evaluate even when nobody vouches for it, because you can bound what it is allowed to access and affect. That does not establish correctness; it limits the consequences of some kinds of failure.
What the manifesto left out is the social half. Verification moves trust onto the spec and the verifier, but somebody has to write those, and strangers have to agree with them. Specs, test vectors and trust roots are a commons too, and they are the part this post says cannot be regenerated. Verification also only checks what someone remembered to specify; the undocumented scar tissue of a mature library is exactly what falls through.
For cancho, this is a design direction, not a description of what it does today. It should not try to become the canonical implementation of every protocol or library it touches. It should make implementations produced by different agents and languages easier to compare and verify: a cancho implementation of a protocol should be able to state the specification version it targets, the conformance corpus it passed, the build inputs that produced it and the capabilities it needs at runtime, and an implementation in another language should be able to publish comparable evidence. Built only by my agents, cancho is a well-built bunker. Publishing its specs, corpora and evidence, not only its code, is what would let anyone else move in.
IX. Coming Up from the Basement
The 2026 debate frames the problem as “AI is killing open source” and the answer as “pay maintainers”. Both are true and both are incomplete. Some of open source should die: the ten-line utility packages were always a liability, and agents are right to stop importing them. What must not die is the layer that was never really code: the specs, the test vectors, the trust roots, the shared memory of what went wrong.
So build the bunker; it is good engineering. Own your parsers, your runtime, even your compiler. But spend the time you save on the radio: conformance suites you publish, hashes you sign, protocols you implement exactly as everyone else does. Software independence turns out to be like the other kind: you keep it by agreeing with your neighbours on a few things that nobody owns.
Open questions: Who maintains incident knowledge and conformance corpora when implementations become disposable, and how is that work funded? Can content-addressing work across languages, or does every language become its own island? Does re-centralisation into distros and vendors count as the commons surviving, or as it being enclosed?
— Alfonso Sastre, November 7, 2026
Sources
- Koren, Békés, Hinz, Lohmann, Vibe Coding Kills Open Source, arXiv, 21 January 2026
- Adam Wathan, comments on tailwindlabs/tailwindcss.com pull request #2388, January 2026
- Daniel Stenberg, The end of the curl bug-bounty, 26 January 2026; The Register, Curl shutters bug bounty program, 21 January 2026
- GitHub Changelog, New repository settings for configuring pull request access, 13 February 2026
- Jeff Geerling, AI is destroying Open Source, and it’s not even good yet, 16 February 2026
- The End of the Dependency Era: Andrej Karpathy and the Rise of LLM-Scraped Functionality, 26 March 2026; yoink, 5 April 2026
- Greg Herlein, Agentic Coding is About to Fracture Open Source, 20 April 2026
- Tim O’Brien, The Fork-It-and-Forget Decade, O’Reilly Radar, 20 January 2026
- Charles Humble, LeadDev, AI-generated abandonware is hollowing out open source, 20 May 2026
- madewithlove, How AI is quietly killing open source
- Ding and Stevens, Stdlib or Third-Party? Empirical Performance and Correctness of LLM-Assisted Zero-Dependency Python Libraries, arXiv, 2026
- HeroDevs, How AI broke open source security, 26 June 2026 (source of the curl CVE projection)
- BleepingComputer (sponsored article by ActiveState), Who Vets AI’s Code? The Scale Challenge Facing Open Source Ingestion, 13 August 2026
- Zhao et al., Commit0: Library Generation from Scratch, arXiv, December 2024
- WebAssembly spec test suite and JSONTestSuite
- Sovereign Tech Agency, ActivityPub Test Suite investment and Sovereign Tech Standards pilot
- Permacomputing wiki, Collapse OS
- Alfonso Sastre, Trust Without Comprehension (the Alpibru manifesto), May 2026