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

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

We commit to

  1. Specify before generating: what it must do, how it's checked and what must never break.
  2. Treat tests as the contract. If a module can be regenerated without touching its tests, the code is replaceable.
  3. Let nothing in without passing controls: tests, mutation testing, static analysis and cross-review between different models.
  4. Verify the controls too: keep them independent from whoever generates, measure whether they catch failures and improve them like the rest of the system.
  5. Put rules in the system, not in the prompt. An instruction can be ignored. A blocking check can't.
  6. Write down what is non-negotiable. A confirmed security flaw gets fixed, not debated.
  7. Record every exception: who granted it, which rule it bypasses, why and until when.
  8. Change the system when a mistake shows up twice, not just the output.
  9. Step in where people add value: when controls disagree, when deciding what to build and when something can't be undone.
  10. Measure what matters: what works in production and who it helps, not lines, PRs or tokens.
  11. 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.

Sign the manifesto Propose a change