Why a new manifesto
Writing code is no longer the slow, expensive part of building software. Knowing what to build, proving it works, and keeping it working are.
The 2001 manifesto was written for a world where requirements were guessed up front and software arrived too late to correct course. Its answer was short feedback loops with real customers, and that answer still holds. But several of its assumptions were about the cost of producing code, and AI has collapsed that cost. A team can now generate more software in a week than it can understand in a month.
We build software with machines that write faster than we can read. Doing that work, we have come to value:
The four values
- Human accountability over automated throughput. Every system has a person who can explain why it works the way it does and who answers for it when it doesn't.
- Verified behavior over plausible software. Software that runs proves very little now. Software that is shown to do the right thing, against a written definition of correct, proves a great deal.
- Explicit intent over implicit knowledge. Decisions, specs, and context written down are what people and agents both build from. What lives only in someone's head is lost the moment they leave.
- Stewardship over shipping. Launch starts a system's life, and most of its cost and value come in the years after.
The things on the right still matter, but AI has made them cheap, and the things on the left are now what's scarce.
The twelve principles
- Our highest priority is putting the right thing, proven correct, in the hands of the people who depend on it, and keeping it correct after the builders have moved on.
- Change is cheap now; deciding is not. We welcome change, even late, and we write down why we changed.
- We deliver as often as the work can be verified, not as often as it can be generated. Review capacity sets the pace.
- The people who know the domain and the people who build work together throughout. More and more they are the same people, which raises the need for discipline.
- Nothing ships that no human can explain. Agents produce; people own.
- Write it down. Specs, decision records, and context are now working parts of the system, read by people and machines alike.
- Progress is measured by behavior proven against a definition of correct. Lines generated, tickets closed, and demos that run are not progress.
- A sustainable pace means sustainable review. When generation outruns the people verifying it, slow the generation down.
- Technical excellence compounds, because AI amplifies whatever it is pointed at. Clean systems get faster. Neglected systems decay faster.
- Simplicity still means maximizing the work not done. Code that is free to write is not free to own, and every line generated is a line someone will maintain.
- Let machines enforce the sequence and let people judge the result. No step begins until the step before it has produced its artifact.
- At regular intervals, the team reflects on how it works with its tools (what to hand to agents, what to keep human, and where review is slipping) and adjusts, because the tools change faster than the habits.
What we kept from 2001
This is not a rejection of agile. Its central bet, short feedback loops with real customers, is stronger now that building is cheap. Customer collaboration, responding to change, and regular reflection all carry over intact.
What we let go of is the assumption that producing code is the bottleneck. That assumption sits behind the original's preference for working software over documentation, its use of working software as the measure of progress, and its delivery cadence of weeks to months. It also sits behind the rituals that grew up around agile, like story points and velocity, which measure effort at a time when effort has stopped meaning much. The work has moved from building to deciding and verifying, and the manifesto should move with it.