In 2011, the twelve-factor app codified how to build software that survived contact with production. It answered the hard questions of its day: where config lives, how dependencies are declared, what a log is. It was right, and it won — so thoroughly that its answers are now defaults you get without asking.
Then the hard things became easy. AI writes the code, wires the deploy, reads the logs. A person with an idea and an afternoon can now build what once took a funded team a year. And in the same motion, things that used to be impossible became hard-but-possible: software crafted for an audience of five, systems no company would ever have staffed, care applied to corners no budget ever reached.
When anyone can build anything, how you build stops being the discipline. What you build, and why, is the discipline. So these factors are not solely technical. They are about the intent behind systems: what a system promises the people inside it, and how honestly that promise is kept.
Like the twelve factors, the eleven are opinions earned by building, not deduced from armchairs. They will be wrong in places. Factor V says that's fine: what matters is that the intent is plain, and that reality can be measured against it.
- I. Trust no one Design so trust is never required
- II. Let kids play If it isn't safe for a child, it isn't safe
- III. Encrypt everything What can be hacked will be hacked
- IV. Great design is for everyone Care is not a premium tier
- V. Intent is the system The value is the ideas, and reality measured against them
- VI. Built by humanity, owned by humanity Software built with AI should be open source
- VII. Self-hosting is a right If you can't run it yourself, you don't own it
- VIII. Many small things Greater than one big thing
- IX. Inefficient builds efficient Spend extravagant machines on lean artifacts
- X. Humans come first AI is opt-in, never required, always disclosed
- XI. Centralised infrastructure is glue Thin, blind, replaceable
I. Trust no one
"Didn't I warn you not to trust anybody, Dr. Jones?"
The old factors assumed an honest operator and a safe server. Assume neither. Not because operators are villains, but because trust that must be extended is a liability that compounds: it can be bought, subpoenaed, phished, or simply leaked by the intern's laptop.
So design systems in which trust is never required. The server holds only what it cannot read. The operator can be curious, coerced, or compromised without the people inside the system losing anything. The database can be published in full and contain no secrets — because it never held any.
There is one measure of this factor: what does an attacker get with total control of your infrastructure? The correct answer is: nothing worth taking.
II. Let kids play
If it isn't safe for a child, it isn't safe.
A system is safe when a child can use it. Not "13+ with a checkbox" — age gates and disclaimers outsource safety to the people least equipped to provide it. If your system requires its users to be street-wise to stay unharmed, the system is unsafe; the wisdom requirement is just the bug's fine print.
Building for kids forces honest defaults: private by default, no strangers by surprise, no dark patterns, no engagement mechanics tuned against an unfinished brain, no data trail that follows them into adulthood. It rules out entire business models — deliberately.
And a system safe enough for a nine-year-old turns out to be exactly the system that respects a ninety-year-old, and everyone in between. Kids are not an edge case. They are the acceptance test.
III. Encrypt everything
What can be hacked will be hacked.
On a long enough timeline, every breach probability goes to one. AI has shortened the timeline: attacks that took skilled labour are now scripts, and every stored plaintext is a promise waiting to be broken by someone who was never party to it.
So treat breach as a certainty and design for the day after. End-to-end encrypt by default: keys live with people, servers store sealed bytes, and "we take your privacy seriously" becomes a property of the mathematics rather than of the press release. Metadata counts — filenames, screen names, and who-talked-to-whom are content too.
Encryption is not a feature tier, an enterprise add-on, or a toggle buried in settings. It is the difference between the breach headline that reads "everything was taken" and the one that reads "there was nothing to take."
IV. Great design is for everyone
Care is not a premium tier.
Great design used to be scarce — rationed out to products with venture budgets and design departments, while everything else shipped as forms over data. AI ended the scarcity. Polish in the smallest interaction — the empty state, the error message, the first sixty seconds — is now a choice, not a resource. The excuse is gone.
"Everyone" means everyone: kids and grandparents, old phones and slow connections, screen readers and shaky hands, the person who will never read documentation and shouldn't have to. Design that only works for the young, fast, and technical is a prototype.
And design is not decoration applied after the fact. It is factor V made visible — the clearest signal of whether the intent behind a system includes you.
V. Intent is the system
The value of a system is the intent and ideas behind it — and how faithfully reality matches them. Not the source code.
Source code was the crown jewels for fifty years. Now it is the cheapest part of any system — regenerable in an afternoon by anyone who understands what the system is for. What cannot be regenerated is the understanding itself: the ideas, the taste, the thousand decisions about what the system promises and refuses.
A system is a set of promises made to the people inside it. Its value is the clarity of those promises and the honesty with which running reality keeps them. Judge systems that way. Fund them that way. Fork them that way.
The corollary stings: guarding source code guards the wrong thing. Your moat was never the code. It is the coherence of your intent, and the trust you earn by shipping a reality that matches it.
VI. Built by humanity, owned by humanity
Software built with AI should be open source.
Every line an AI writes is distilled from the accumulated work of millions of people who wrote, answered, documented, and argued in public. Software built with AI has uncredited co-authors beyond counting. Open source is not generosity here; it is honest accounting. The commons built it, so it returns to the commons.
It is also the only way the other factors can be checked. "Trust no one" (I) and "encrypt everything" (III) are claims — and a claim you cannot audit is marketing. Open source turns promises into inspectable properties.
And since the value of a system is its intent, not its code (V), you give up almost nothing. Anyone can copy your source. Nobody can copy why.
VII. Self-hosting is a right
Software built with AI should be possible to self-host.
If a system can only run on its maker's servers, its users don't have software — they have a subscription to their own data, revocable at any funding round. Every promise the system makes is conditional on a company's continued existence and continued interest in keeping it.
AI dissolves the old excuse that self-hosting is too hard for ordinary people: everyone has an ops team now. What remains is the builder's obligation to make it possible — ship the system as something a person can run. One binary. One file of data. One small machine.
Self-hosting need not be the default; convenience is allowed. But the exit door must exist and must open. A promise you cannot walk out with is a terms-of-service clause, not a promise.
VIII. Many small things
Many small things are greater than one big thing.
One big thing fails big, leaks big, and is worth attacking big. A thousand small instances — each holding one family's, one team's, one town's affairs — offer no jackpot. Small is a security boundary, a blast radius, and a form of respect: your community's system, not your account on someone's platform.
Small is also comprehensible, and comprehensible is the new fast. A system that fits in one person's head — or one model's context window — can be audited, rebuilt, and repaired by anyone. Complexity used to be a moat; now it is just a place for bugs to hide.
The big thing that remains worth building is the pattern, the protocol, the shape that lets ten thousand small things interoperate without a centre. Build the mold, not the monolith.
IX. Inefficient builds efficient
Use inefficient systems to create efficient systems.
A large language model is a spectacularly inefficient way to compute anything — and the finest tool ever made for creating things that compute efficiently. That is not a paradox; it is a division of labour as old as tooling. The kiln burns hot so the brick doesn't have to.
So spend the extravagance where it multiplies: at build time. Let the profligate machine write the tight loop, the small binary, the dependency-free page that will run for a decade on a $4 computer without ever needing the machine again. The artifact should not inherit the appetite of its author.
Beware the inversion — wiring an LLM into the hot path of a system because it was the easiest thing to reach for. That is bringing the kiln to the dinner table. (It also violates factor X.)
X. Humans come first
AI is not the default. AI is opt-in, never required, always disclosed.
These factors exist because of AI, and this one keeps it in its place. A system is for the people inside it. No one should have to talk to a machine to use a thing, no one should be surprised to learn they were talking to one, and nothing essential should sit behind an AI that a human never chose.
So: opt-in — AI arrives because a person invited it, and leaves when a person removes it. Never required — every path through the system works with the AI switched off. Always disclosed — machine-made words and machine members are visibly marked, the way this document is marked 🤖, so no one ever has to wonder.
Done this way, an AI in a system is a guest with a name tag. Done any other way, it is an infestation.
XI. Centralised infrastructure is glue
Thin, blind, replaceable.
Purity says decentralise everything; reality keeps a few jobs that genuinely want a centre — push notification relays, discovery, backup stores, the boring plumbing between sovereign small things (VIII). Fine. Let them be central. But let them be glue: the thin layer that holds parts together and knows nothing about what it holds.
Glue is blind — a relay forwards sealed bytes it cannot open; a home server stores encrypted backups it cannot read. Glue is thin — auth tokens and routing, never content, never keys. And glue is replaceable — anyone can run their own batch, and swapping it breaks nothing that matters.
The test is the subpoena, the seizure, the hack: when the central piece falls, the people inside the system lose at most some convenience — never a word they said. If losing your centre loses their content, you didn't build glue. You built a vault with your name on the door, and factor I already told you how that story ends.