IAGREED
From idea to documentation — in order, every time.
IAGREED is the seven-stage lifecycle that every feature, product, or significant decision moves through. It replaces ad-hoc execution with a predictable rhythm that both humans and AI agents can follow.
When To Use This
IAGREEDis for you if…
- You're shipping features with AI agents and the quality swings wildly from run to run.
- You keep skipping "just one" stage — usually Audit or Document — and regretting it two weeks later.
- Your team keeps re-deciding decisions you already made, because nobody wrote them down.
- You want a predictable rhythm without waterfall ceremony — a real lifecycle that humans and agents can share.
The Parts
What's Inside IAGREED
Capture the spark. Structured enough to revisit, loose enough to explore.
Stress-test the idea. What could kill this? What's missing? Where are the landmines?
Write the PRD. Design the architecture. Decompose into workflow prompts.
Tighten the plan against the codebase. Close loopholes before any code is written.
Build it. Ship the code. Work through the workflow prompts from the Gameplan.
Measure what shipped against what was planned. Find the gaps. Run the retro.
Harvest DOTs from the build. Write reference docs. Update HUMAN.md. Compound the knowledge.
Why Every Stage Exists
Every stage of IAGREED exists because skipping it causes a specific failure mode.
- Skip Idea capture → good thoughts die in your head within 48 hours.
- Skip Audit → you build the wrong thing, expensively.
- Skip Gameplan → you start coding without knowing where the walls are.
- Skip Refine → the plan fights the codebase once implementation begins.
- Skip Execute → obvious.
- Skip Evaluate → you keep repeating the same gaps because nobody looked.
- Skip Document → the lessons don't compound. You pay for them again next quarter.
IAGREED is the discipline of never skipping a stage. Agents enforce it. The human benefits from it.
The Two Audits
Audit happens twice. Once after Idea (does the idea deserve investment?), and once after Execute (did we build what we said?).
The post-Idea audit is ruthless. Its job is to kill weak ideas before they consume resources. Every audit finds at least one real risk — no rubber stamps.
The post-Execute audit — technically Evaluate — is reflective. It asks whether the build matches the plan, what surprised us, and what DOTs we should harvest.
Different modes. Same respect for the question: "are we sure?"
Why Document Is Last — And Most Important
Most teams end at Execute. They ship, declare victory, and move on.
IAGREED ends at Document, and it's non-negotiable.
Every build produces knowledge. If you don't harvest it — turn it into DOTs, update reference docs, refresh HUMAN.md — then the next build starts from zero. You're paying the same tuition twice.
Document is where the flywheel lives. Skip it, and IAGREED becomes just a different name for waterfall. Include it, and every cycle makes the next one faster.
How Agents Use It
IAGREED isn't just a mental model. It's the protocol AI agents follow inside the Command Center.
Each stage has a persona — Strategist, Auditor, Architect, Builder, Evaluator, Librarian. Each persona has skills, memory, and guardrails scoped to its stage.
When a project advances, the baton passes. The Strategist doesn't write code. The Builder doesn't write PRDs. Each agent does one stage well, and the context flows forward cleanly.
That's the difference between "using AI" and operating an AI team. IAGREED is the org chart.
The Traps
Common Mistakes With IAGREED
Starting at Execute
Jumping straight to build because "we already know what we want" is how you ship the wrong thing — beautifully. Idea, Audit, and Gameplan are compression passes on the problem. Skip them and you spend Execute fighting a plan you never actually wrote down.
Audit as a rubber stamp
If your Audit didn't find a single real risk, you didn't audit — you confirmed. Every Audit should surface at least one landmine, one unknown, or one assumption the team is quietly making. If it can't, the Auditor isn't doing their job.
Declaring victory at Ship
The build isn't done when the feature ships. It's done when the lessons from the build are harvested into DOTs, reference docs, and HUMAN.md updates. Skip Document and the next cycle starts at zero. IAGREED without Document is just waterfall with better marketing.
Objections Answered
But What About…
Waterfall flows one direction and punishes change. IAGREED loops — Document feeds the next Idea. It's only waterfall if you ship exactly one feature and quit. The cycle is the whole point.