A rolling manifesto for building software with AI agents, in the spirit of the 2001 Agile Manifesto.
In February 2001, seventeen practitioners met at Snowbird and wrote the Agile Manifesto. They did not overthrow engineering, they named what the best teams already did.
A quarter century later, the same moment has arrived again.
An honest estimate in early 2026:
"integrate Auth0 natively into our mobile app", six months, one team.
The same work, scoped for a single developer pairing with Claude Opus 4.7, one sprint.
The same work, actually done, two days.
That is not a productivity improvement. A 90× shift in the cost of producing code breaks the unit of thought that agile was built around: the sprint, the point, the estimate, the ceremony.
When the thing you were scheduling now fits between lunch and a coffee, the calendar you built around it becomes scaffolding around empty space.
This manifesto does not retire agile. It retires the parts of agile that assumed typing was slow, context was expensive, and humans wrote every line.
The four values and twelve principles below are what remains when those assumptions go.
We are uncovering better ways of developing software by doing it with AI agents and helping others do it.
Through this work we have come to value:
Intent over specification Validation over verification Human-agent collaboration over individual productivity Reversibility over estimation
That is, while there is value in the items on the right, we value the items on the left more.
A specification tells a machine what to do.
An intent tells it what you want.
When the machine can fill in the "how," a detailed specification becomes a bottleneck, it locks in the author's best guess at a solution instead of the user's actual goal.
The skill is no longer writing precise requirements; it is holding a clear intent loose enough that the agent can find a better path to it.
Verification asks: did it do what I said?
Validation asks: did it do what I wanted?
Tests, types, linters, and CI answer the first.
They do not answer the second.
With non-deterministic agents producing code faster than any human can read, the team's moat is validation, staging environments, feature flags, telemetry, real users, and the taste to recognize "correct but wrong."
The solo developer running five agents is not the unit of the future.
That developer is a bottleneck: 5× the code, 1× the review capacity, 0× the shared context.
The team still exists; it now includes non-human members.
Standups, reviews, and decisions must be designed for a team whose fastest members do not get tired and whose slowest members set the pace.
An estimate answers when will it be done?
Reversibility answers what happens if we ship it and we were wrong?
When a feature costs two days to build, the question shifts from scheduling to blast radius.
Feature flags, canary deploys, and one-click rollback are the new points on the board.
A team that can undo any change in under an hour does not need a burndown chart.
Our highest priority is to satisfy the customer through continuous delivery of validated outcomes, not merely working code.
Welcome changing requirements at any point, including mid-sprint. When a feature costs days instead of months, changing your mind is cheap; refusing to is expensive.
Deliver working software many times per day. The unit of delivery is now the pull request, not the sprint.
Product, design, engineering, and agents work together continuously. The agent is a participant in the working session, not a tool used after it.
Build teams around humans with clear intent. Give them agents, review capacity, and the authority to reject AI output. Trust them to distinguish impressive from correct.
The most efficient method of conveying intent to an agent is a written specification the agent can re-read. The most efficient method of conveying intent within a team is still face-to-face conversation. Do not confuse the two.
Validated outcomes in production are the primary measure of progress. Lines of code, merged PRs, and closed tickets are vanity metrics when an agent can produce them on demand.
AIgile processes promote sustainable development. Sponsors, developers, and agents should maintain a constant pace indefinitely, where "pace" is measured in human review capacity, not agent throughput.
Continuous attention to technical excellence is what prevents AI-generated code from becoming AI-generated debt. Architecture, naming, and tests matter more now, not less.
Simplicity, the art of maximizing the amount of work not done, by humans or agents, is essential. The cheapest code to maintain is the code that was never written, regardless of who would have written it.
The best architectures, requirements, and designs emerge from teams that treat agents as collaborators with strong opinions and no skin in the game. Listen to them; do not obey them.
At regular intervals, the team reflects on which ceremonies still create value and which are rituals around a bottleneck that no longer exists. It tunes and adjusts, including by deleting itself.
The original purpose was alignment when status was expensive.
Agents now produce a standup digest from the night's PRs, builds, Slack threads, and ticket moves before humans wake up.
The human standup, if it survives, becomes a five-minute decision meeting: what are my agents blocked on that only a human can unblock?
Pointing work is a vestige of a world where effort was the constraint.
Split the backlog into AI-ready, human-required, and human-reviewed.
Point the review, not the build.
Plan against token budgets and reviewer attention, not developer hours.
Story points for AI-suitable work are a rookie mistake by 2026.
The honest estimate is time to validate, not time to produce.
For work an agent could plausibly one-shot, the only useful number is how long a human needs to be sure.
Humans can only reflect as well as their memory allows.
Feed the retro agent the last two weeks of tickets, PRs, incidents, and Slack; let it surface patterns no one saw.
Then do the human part: decide what to stop doing.
Put WIP limits on the review columns, not the build columns.
The bottleneck is no longer capacity to produce; it is capacity to trust.
A team of one human and five agents with no WIP limit on "awaiting review" is a team building technical debt at machine speed.
When everything is cheap to build, prioritization becomes the only real engineering activity.
"Should we build this?" is now harder than "can we build this?", and it is the question the team should spend the most time on.
Most teams still run two-week sprints by muscle memory.
The early adopters have quietly deleted them and nobody noticed.
Story points are gone from 40% of teams.
Review queues are the new bottleneck; review tooling becomes a product category.
"Planning" and "estimation" merge into a single weekly prioritization meeting.
The question is always should we, rarely can we.
Sprints are historical.
Teams operate on continuous flow with human checkpoints at validation boundaries, not calendar boundaries.
A new generation of engineers has never filled in a story-point field.
They will find our 2001 artifacts charming, the way we found Gantt charts charming in 2001.
It was the recognition that software is made by humans for humans, under uncertainty, and that pretending otherwise makes it worse.
Agents do not change that.
They raise the stakes of getting it right, because the cost of getting it wrong has dropped at the same speed as the cost of building.
The signatories of 2001 were not wrong.
They were writing for a world where typing was the bottleneck.
We are writing for a world where judgment is.
Living document, 2026. Revised annually. Signatories optional, if you ship with agents, you are already writing it.
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。