Blog

Software Preppers: Dependencies After the Commons

Code is getting cheap. The agreement that makes it useful is not

Alfonso Sastre — November 7, 2026

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.

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:

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.

LayerWhat you can do alonePrepper 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:

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