Build what you want
Start from an outcome, not a pile of disconnected coding tasks.
A delivery system, not a coding assistant
AI can move fast. AIM makes sure it moves in the right direction.
AIM gives AI work a destination, a controlled next step, evidence before acceptance, and a human decision when it matters.
Never lose track
Keep the Epic, approved increment, evidence, and next decision visible.
Quality first
Make review, validation, and correction part of delivery rather than cleanup.
Human controlled
People retain ownership of scope, trust decisions, releases, and completion.
One repeatable delivery loop
From product intent to accepted software.
AIM separates responsibilities so planning does not silently become implementation and generated work does not silently become accepted work.
Set direction
Define the Epic, value, boundaries, and acceptance intent.
Shape the increment
Choose one useful, reviewable slice of the outcome.
Build it
Implement the approved increment end to end.
Challenge it
Find correctness issues, edge cases, and risk.
Validate it
Check evidence against the increment and Epic.
Decide
Accept, adjust, continue, or close the Epic.
AIM does not promise that AI is always correct. It creates repeated opportunities to discover mistakes before they are accepted, and sends failed work back for correction.
Generation is the beginning. Evidence decides what is done.
Built for real repositories
Rich when needed. Lightweight by default.
AIM learns enough to work safely, remembers useful repository knowledge, and expands context only when the task, evidence, or risk requires it.
Understands local reality
Technologies, commands, important folders, conventions, risks, and relevant documentation.
Remembers what matters
Shared repository facts and personal hints persist without becoming one giant active prompt.
Your tokens are valuable
Start from compact state and load deeper operational truth only when it becomes relevant.
Problems return for repair
Blocking review findings and failed validation prevent silent completion.
Rebuilt for AIM 2
Cleaner architecture. Easier adoption.
AIM 2 was rebuilt while preserving the proven delivery loop. Workflow, repo awareness, runtime state, installation, and platform adapters now have clearer boundaries.
Guided installation
Preview before changes
Reversible setup
Update as the project changes
Remembers repository facts
Loads detail only when needed
One product, adapted to each project
Install AIM once. Let every role become a project specialist.
AIM keeps one delivery method while configuring native PO, TDO, Dev, and Reviewer specialists for the suppliers and technologies your project actually uses.
One AIM method
Every adapter preserves the same role order, gates, runtime state, and acceptance contract.
Consistent where consistency matters- The main AIM thread always owns scope, gates, and acceptance.
- Sequential fallback keeps the method reliable when delegation is unavailable.
Project specialists
Each supplier uses its own project-agent format, tuned from one readable role profile.
Specific where specificity helps- React projects can teach Dev the right architecture and commands.
- Playwright projects can give Reviewer the strongest relevant test workflow.
Your policy
Sharing, repository writes, permissions, models, and tools remain explicit project or organization choices.
Safe without separate editions- Defaults inherit supplier and organization settings.
- Legacy install flags remain available for reviewed migrations.
Native where you already work
Codex, Claude, and GitHub Copilot.
Each platform gets a natural entrypoint. The delivery loop, quality rules, ownership, and acceptance stay shared.
Codex
Use the AIM skill under ~/.agents/skills/ for the complete /aim command family, plus project custom agents under .codex/agents/.
/aim start "EPIC: ..."
Claude
Use the project AIM skill under .claude/skills/aim/, with project subagents under .claude/agents/.
/aim start "EPIC: ..."
GitHub Copilot
Use the project AIM skill under .github/skills/aim/, backed by repository custom agents under .github/agents/.
/aim start "EPIC: ..."
Your first AIM journey
Choose your installation path. Start building with confidence.
Install the complete portable Agent Skill through the standard skills CLI, or use the adaptive installer for repository-aware setup and native project specialists. Both paths deliver full AIM.
Install the complete public Agent Skill
Use the common skills CLI for a self-contained AIM package that works without the source repository. It is generated from canonical AIM sources, preserves every role and gate, and is full AIM rather than AIM Lite.
npx skills add joneri/agile-iteration-method --skill agile-iteration-method
Already have AIM 1.x or older AIM files?
Run the packaged upgrade path before starting or resuming work. It refreshes installed AIM surfaces while preserving active runtime state.
/aim upgrade
One installation, native to your tools
Select Codex, Claude, GitHub Copilot, or any combination. AIM installs each native skill, its project specialists, and only the shared contracts they need.
Project-aware
AIM detects conservative stack and validation facts and writes them to a readable aim.roles.yaml profile.
User-controlled
Review native role files, edit them directly, or ask AIM to refresh them when the stack or test strategy changes.
Existing customizations remain collision-protected.After install, teach AIM the repository
Start by upgrading existing AIM files when needed, calibrating repository awareness, and remembering important product context that should guide future work.
Install AIM
Choose the repository and the adapters you use.
Calibrate
Verify the smallest useful repository understanding.
Start an Epic
Describe the outcome you want, not a task pile.
Review Gate A
Confirm direction, boundaries, risks, and acceptance.
Approve the slice
Work through one useful Done Increment at a time.
Accept evidence
Review what changed, what passed, and what remains.
Review the adaptive installer
Choose this path when you also want repository inspection, adapter selection, an initial role profile, and native project specialists. Clone the public source, inspect it locally, and begin with a no-write preview.
git clone --depth 1 https://github.com/joneri/agile-iteration-method.git aim-source
Go deeper when you need to