The Unread Manifesto
A case for Policy-Driven Development
Software quality doesn't depend on a person reading every line, but on a system that guarantees what comes out is good and correct.
AI already writes much of our code, docs and plans. Just as nobody reads the machine code a compiler emits, and no CTO reads all of their team's code, we don't need to look harder. We need to guarantee better.
We value
- Verified outcomes over lines read
- Clear specifications over detailed specs
- Controls in the system over trusting good will
- Human judgement on the what over human review of the how
- Improving the system over patching the output
In the spirit of the Agile Manifesto: while there is value in the items on the right, we value the items on the left more.
We believe
- Quality never depended on reading everything. No team ever did. We delegate to people with tests, acceptance criteria and someone accountable. AI is no different.
- No two developers write the same code. What matters is not how it's written, but that it does what was specified and can be changed safely. That is why design properties are part of the contract too.
- Code is becoming an intermediate artifact, like assembly once was. What we really maintain is the specification, the tests and the rules.
- The problem isn't what nobody read. It's what nobody can verify. Work that passes good controls isn't slop, even if no one read it. Work no one can check is, whether a person or a model made it.
- Reading more doesn't scale. An agent produces in a day more than a person can review in months. The only review that scales is the one built into the system.
- People are essential where there's no substitute: understanding the domain, deciding what to build, specifying it well and answering for the result.
We commit to
- Specify before generating: what it must do, how it's checked and what must never break.
- Treat tests as the contract. If a module can be regenerated without touching its tests, the code is replaceable.
- Let nothing in without passing controls: tests, mutation testing, static analysis and cross-review between different models.
- Verify the controls too: keep them independent from whoever generates, measure whether they catch failures and improve them like the rest of the system.
- Put rules in the system, not in the prompt. An instruction can be ignored. A blocking check can't.
- Write down what is non-negotiable. A confirmed security flaw gets fixed, not debated.
- Record every exception: who granted it, which rule it bypasses, why and until when.
- Change the system when a mistake shows up twice, not just the output.
- Step in where people add value: when controls disagree, when deciding what to build and when something can't be undone.
- Measure what matters: what works in production and who it helps, not lines, PRs or tokens.
- Own what we ship, whoever wrote it.
In short
We don't ask for blind trust in AI, nor reflexive distrust. We ask for what has always worked with any team: clear intent, controls that don't depend on good will, and someone accountable for the result. The rest, the machine can do.