AI Manifesto
The Agile Manifesto was written in 2001 in response to heavyweight, process-centric software development. It argued that collaboration and results mattered more than rigid plans and documentation. That is still true, but AI changes the economics:
- Software creation is becoming abundant.
- The scarce resource is no longer programming capacity, but organizational clarity.
As implementation capacity becomes abundant, business knowledge, context, judgment, and rapid learning become the new constraints.
What We Learned from Agile
Agile began as a rebellion against heavyweight processes, yet years later many organizations ended up with even more structure, process and bureaucracy. The old processes and roles morphed into different ones:
- Standups replaced status meetings.
- Story points replaced estimates.
- Scrum Masters replaced project managers.
- Agile Transformation Offices replaced project management offices
If Agile failed at the enterprise level it failed because organizations missed the true message. They adopted the ceremonies while preserving the underlying bureaucracy. Critics call this the “Agile Industrial Complex” or made fun of enterprise adoption in the Manifesto for Half-Arsed Agile Software Development.
Sometimes Agile processes were adopted within technology organizations without full buy-in from stakeholders. Often stakeholders didn't fully understand it, and felt left out. Many organizations somehow missed the fact that the goal of the Agile Manifesto was to make software engineering closer to stakeholders and less bureaucratic.
It's been 25 years since the Agile Manifesto was created. Maybe it's time for a refresh?
A New AI Manifesto (Draft)
"We believe the future belongs to organizations that learn faster than their competitors. AI does not remove the need for human expertise. It amplifies it. The winners will not be those who generate the most software. They will be those who best understand the problems worth solving."
We believe:
- Software development is no longer constrained by coding capacity.
- AI amplifies expertise, judgment, and context more than it amplifies programming skill.
- The future belongs to teams that can learn faster than competitors, not teams that can code faster.
- Software quality and business value degrade as the distance between stakeholders and engineering increases.
We value:
Business understanding over code production
The ability to understand customer needs, business goals, and operational realities is more valuable than the ability to generate code.
Proximity over handoffs
The people who understand the problem should be as close as possible to the creation of the solution.
Context over specifications
Rich context enables effective AI systems. Detailed specifications become less important when goals, constraints, and domain knowledge are clearly understood.
Rapid learning over rigid planning
The cost of implementation is falling. The value of discovering the right solution is rising.
Architectural coherence over implementation volume
When software can be created quickly and cheaply, maintaining coherent systems becomes more important than producing more code.
While there is value in the items on the right, we value the items on the left more:
| More Valuable | Less Valuable |
|---|---|
| Business understanding | Code production |
| Context | Specifications |
| Learning | Planning |
| Stakeholder collaboration | Requirements handoffs |
| Domain expertise | Technical specialization |
| Outcomes | Deliverables |
| Architectural stewardship | Generated code |
We reject:
- AI governance that slows learning.
- Organizational structures and processes that create distance between stakeholders and engineers.
- Metrics that reward output rather than outcomes.
Supporting Principles
1. The primary constraint is understanding, not implementation.
As AI reduces the cost of creating software, the hardest problem becomes determining what should be built.
2. The shortest path between a business problem and a solution is preferred.
Every organizational layer between problem identification and solution delivery introduces delay and information loss (waste). Every handoff acts like friction in a mechanical system. Information loses fidelity each time it passes through another person, document, meeting, or management layer.
3. Those closest to the problem should shape the solution.
Domain expertise increasingly outweighs implementation expertise.
4. Human judgment remains accountable.
AI may generate solutions, but humans remain responsible for decisions, tradeoffs, risks, ethics, and outcomes.
5. Context is the new source code.
Organizational knowledge, customer understanding, business rules, architecture, and operational constraints are increasingly valuable assets.
6. Architecture matters more as implementation becomes cheaper.
When code generation is abundant, system design, maintainability, governance, and long-term coherence become more important.
7. Iteration should occur at the speed of learning.
The goal is not to maximize coding throughput but to maximize validated understanding.
8. Small, empowered teams outperform large coordination structures.
AI increases the leverage of individuals and small groups, reducing the need for large implementation organizations and heavy processes.
9. Knowledge should reside near decision-making.
Separating domain experts from builders creates friction and information loss (waste).
10. Measure outcomes, not activity.
Lines of code, story points, tickets completed, and hours worked are poor measures of value creation.