Shape the Backlog
Turn desired outcomes into ordered Epic candidates visible in AIM UI.
How Portfolio Auto works
One mandate starts the portfolio. Every Epic still earns Done.
Portfolio Auto turns an ordered AIM UI Backlog into a controlled delivery run. You approve the exact snapshot once. AIM then completes each candidate through the full role loop and pauses when scope, safety, evidence, or a final product decision needs you.
Start from chat
/aim start "PORTFOLIO" mode:auto
Approve one snapshot
AIM freezes the included cards and asks for one bounded Portfolio mandate.
Run the full loop
Each Epic moves through PO, TDO, Dev, Reviewer, TDO, and PO with durable evidence.
Return control at the edge
Changed scope, unsafe effects, weak evidence, and final acceptance come back to you.
Autonomy for the repeatable work. Human authority for the decisions that change the product.
That is the useful trick: Portfolio Auto is not an instruction to “keep coding.” It is an immutable queue, one active candidate at a time, a complete AIM loop per Epic, and an inspectable checkpoint after every transition. You get sustained momentum without turning speed into silent scope or unreviewed completion.
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.
Build what you want
Start from an outcome, not a pile of disconnected coding tasks.
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.
Writes for the reader, not its own chat
AIM communicates the intended current meaning directly. Private conversations, rejected drafts, AI mistakes, prompts, and review feedback stay out of product copy, UI labels, code comments, and documentation unless history is the artifact's actual purpose.
Beta
AIM UI · the delivery loop made visible
This is where AI work stops feeling invisible.
AIM UI brings the whole product journey into one control room: shape direction with Discuss, review the Roadmap, start a bounded Portfolio, follow every role and Gate, inspect delivery evidence, and continue eligible decisions in the connected Codex task.
Calibrate. Discuss. Shape the Roadmap. Approve one mandate. Then monitor the work—or go take a walk.
See the portfolio move together
Every Increment keeps a clear Epic identity while several independently authoritative workspaces share one board.
Only real work moves
Quiet polling leaves cards still. A genuine state transition moves only the affected ticket between workflow stations.
Continue the same task from the card
Launch AIM UI from the authoritative Codex task and eligible Start and Approve actions run there directly after server-side freshness checks.
The UI observes. AIM decides.
The browser cannot pass Gates or write runtime state. Human ownership and AIM's canonical role loop stay intact.
Think before you promote work
Explore product direction with relevant repository knowledge, decisions, and accepted delivery evidence—without changing the Backlog or starting delivery.
See outcomes with receipts
Inspect accepted Increments, elapsed delivery evidence, complete history, and the people or helper agents behind each Epic.
Repository learning with current evidence
Dreams consolidate memory. Reflect makes repository knowledge prove itself.
AIM Reflect goes beyond memory cleanup for repository work. It finds lessons in completed delivery, verifies them against current evidence, preserves provenance and contradictions, and asks you before anything becomes durable knowledge.
This comparison uses Anthropic's public description of Dreams; Reflect is AIM's repository-delivery answer, not a claim to replace every memory system.
/aim reflect
Turn completed AIM history into temporary, evidence-backed knowledge candidates for the repository you are working in.
/aim reflect-all
Preview selected local AIM projects, then find project, cross-project, personal, and AIM-product insights without modifying any source repository.
Every lesson has receipts
Repository paths, current-source verification, confidence, contradictions, destination, and promotion action travel with every candidate.
Reflection never becomes authority by accident
Reports stay temporary under .aim/analysis/. Profiles, docs, code, and other repositories remain unchanged until you approve a separate promotion.
AIM UI
Start Epic · Approve Gate
Your authoritative Codex task
Same thread · same model settings · same repository
Change requests and free-form discussions still open a reviewed handoff. If the task is busy or needs attention, AIM stops and tells you—nothing silently continues.
AIM 3 · from idea to moving portfolio
The UI does more than show the board. It teaches the route.
After calibration, open AIM UI from Codex. Use Discuss to shape direction with relevant durable repository knowledge, explicitly promote the result into a Roadmap, review the cards, and start Portfolio Auto.
/aim calibrate-repoPreview before changes with a verified repository baseline
/aim uiOpen and connect the control room
/aim discussShape direction without starting work
/aim to-backlogExplicitly populate the Roadmap
/aim start "PORTFOLIO" mode:autoFreeze one ordered snapshot
Approve the mandate
Monitor progress—or take a walk
Monitor progress—or take a walk
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