Silent Drift
AI produces code that seems correct but subtly deviates from your intention. Without knowing it, you accumulate invisible technical debt.
Open Source Methodology
Multi- Adversarial Agent Driven Development
When AI codes faster than you can specify, your methodology must evolve. MADD provides the framework to control drift and drive convergence between intention and implementation.
$
npx degit madd-sh/madd-boilerplate-opencode my-project$
npx degit madd-sh/madd-boilerplate-docker-cagent my-project$
npx degit madd-sh/madd-boilerplate-claude my-project$
npx degit madd-sh/madd-boilerplate-codex my-projectThe Problem
AI-assisted development changes everything,
except our methodologies.
False Alignment
The agent says "done" but left TODOs, partial implementations, ignored edge cases. The code passes tests but doesn't solve the problem.
Context Loss
Each session starts from scratch. Architectural decisions get lost. Conventions erode. The project becomes an incoherent patchwork.
Biased Validation
The agent that generates the code is the same one that documents it. It's the fox guarding the henhouse. Self-evaluation masks problems.
The Fundamentals
6 Principles for Zero Drift
Intention is a first-class artifact
Intention is not a forgotten conversation. It's a versioned, structured document that answers "why" and "what" before any "how".
→ Before generating code, intention must be formalized and validated.
The contract is executable
A specification that can't be automatically verified isn't a contract, it's a wish. Every requirement has automatable validation criteria.
→ Tests, assertions, schemas: the contract verifies itself.
No agent validates its own work
An agent that generates code cannot be the source of truth on that code's quality. Validation must always come from an agent that didn't participate in production.
→ Mandatory architecture with 4 minimum roles.
Retro-specification is the system's memory
What was actually implemented must be documented objectively, independently of what the development agent claims to have done.
→ An independent Scribe agent analyzes the code and produces the truth.
Foundations precede features
When marginal development cost decreases, investing in architecture becomes rational. We prioritize what de-risks what comes next.
→ Sequencing favors solidity, not immediate impressions.
Skills are knowledge contracts
AI has outdated training data. Skills inject up-to-date knowledge and define quality criteria between phases.
→ Each transition is mediated by an explicit skill.
The Architecture
4 Agents, Zero Conflict of Interest
Each agent has a unique role. None validates its own work.
📋
Spec
Formalizes intention
↓
FEEDS
📜
CONTRACT
Intention + Validation criteria
↓
↓
↑
GUIDES
RETRO-SPECIFIES
⚡
Dev
Implements the contract
→
🔍
Audit
Verifies against the contract
📝
Scribe
Documents reality
📋
Agent SpecThe Intention Architect. Formalizes the "why" and the "what".
- Produces the Intention Document
- Defines validation criteria
- Structures the executable contract
⚡
Agent DevThe Developer. Transforms intention into code.
- Generates the implementation
- Respects the contract
- Documents technical choices
🔍
Agent AuditThe Verifier. Audits without complacency.
- Analyzes produced code
- Verifies intention/code alignment
- Identifies drifts and risks
📝
Agent ScribeThe Witness. Documents objective reality.
- Analyzes what actually exists
- Compares specs vs reality
- Produces the retro-specification
Migration
MADD vs Legacy Methodologies
| Aspect | Scrum / Kanban / SAFe | MADD |
|---|---|---|
| Bottleneck | Development time | Intention clarity |
| Work unit | Story / Ticket | Intention + Contract |
| Estimation | Points / Days | Obsolete (too fast) |
| Validation | Human code review | Independent agent audit |
| Documentation | Often neglected | Automatic retro-spec |
| Rhythm | Fixed sprints (2-3 weeks) | Adaptive cycles |
| Coordination | Team ceremonies | Inter-agent contracts |
| Project memory | In people's heads | Versioned retro-spec |
Quick Start
Getting Started with MADD
1
Separate your agents
Use 2-3 different models: Gemini for specs, Claude for dev, GPT for audit. Never let an agent validate its own work.
2
Formalize before coding
Before each dev session, write an Intention Document: why, what, success criteria. This is your contract.
3
Audit each delivery
Pass the produced code to your audit agent with a due diligence skill. Never merge without independent audit.
4
Generate the retro-spec
A 4th agent (or you) analyzes what was actually implemented and updates the documentation. This is your project memory.
1
Assign roles
Intention Architect (PM/PO), Agent Orchestrator (senior dev), Alignment Arbiter (QA or peer). Each role is responsible for a phase.
2
Centralize skills
A shared repo with all skills: Spec Skill, Dev Skill, Audit Skill, Retro-Spec Skill. Versioned like code.
3
Retro-spec as source of truth
The retro-specification is shared and updated each cycle. It's the starting point for every new iteration.
1
Sprints → Intention Cycles
No more fixed duration. A cycle starts when an intention is formalized and ends when the retro-spec is validated.
2
Stories → Intention Docs + Contracts
Each story becomes an Intention Document with executable validation criteria. No more "looks good to me".
3
Definition of Done → Audit Skill
The DoD becomes a formal skill that the audit agent executes. Verifiable, reproducible, non-negotiable.
4
Retrospectives → Consolidations
No more "how to improve the process". We consolidate retro-specs and improve skills.
Ready for Zero Drift?
MADD is open source. Join the community and help define the future of AI-assisted development.