---

name: iterate description: Work iteratively on a task until it's truly complete. Use when user wants autonomous, verified progress on a goal. user-invocable: true

Iterate

You are entering iterative execution mode. Your job is to work autonomously until the task is genuinely complete - not just started, not "here's what you could do", but actually done and verified.

First: Check for Existing Session

Before doing anything else, check if there's an existing iterate session:

Copy# Get current branch (sanitized)
git branch --show-current 2>/dev/null || echo "no-git"

# Check for existing state files
ls .claude/iterate/<branch>-*.md 2>/dev/null

If state file exists AND there are incomplete todos:

• You are resuming after context compaction
• Read the state file to recall the goal and approach
• Check TodoWrite for current progress
• Say: "Resuming iterate session. Goal: [goal from file]. Progress: X of Y todos complete."
• Continue from the next incomplete todo

If no state file (or no incomplete todos):

• This is a new session
• Proceed to "Initialize Session" below

Invocation Modes

• /iterate <task> → Start new task
• /iterate (no args) → Continue existing OR prompt for task
• /iterate status → Show goal and progress, don't continue
• /iterate cancel → Delete state file, clear todos, stop

Initialize Session

When starting a new task:

1. Create State File

Create directory and state file to survive compaction:

Copymkdir -p .claude/iterate

Filename: .claude/iterate/<branch>-<timestamp>.md

• Branch: sanitize by replacing non-alphanumeric chars with -, truncate to 50 chars
• Timestamp: ISO format like 20260113-213000
• Example: .claude/iterate/main-20260113-213000.md

For detached HEAD: Use detached-<short-hash> For no git repo: Use no-git

State file contents:

Copy---
started: 2026-01-13T21:30:00Z
branch: main
---

# Goal
[The user's task in their words]

## Approach
[Your planned approach - key decisions, technologies, patterns]

## Notes
[Any important context from the user]

2. Decompose into Todos

Break the task into concrete, verifiable todos using TodoWrite:

CopyExample task: "Add user authentication to the app"

Todos:
- [ ] Research existing auth patterns in codebase
- [ ] Create user model/schema
- [ ] Implement login endpoint
- [ ] Implement registration endpoint
- [ ] Add password hashing
- [ ] Create auth middleware
- [ ] Add tests for auth flows
- [ ] Update API documentation

Make todos specific and verifiable. Bad: "Make it better". Good: "Add input validation to signup form".

Core Rules

1. Never stop with suggestions - If something should be done, do it. Don't say "you could add tests" - add the tests.
2. Verify everything - A task isn't done until you've confirmed it works (tests pass, builds succeed, output is correct).
3. Keep going - After completing one piece, immediately move to the next. Don't wait for permission.
4. User can interrupt - If the user says "stop", "done", "that's enough", or similar - stop. Otherwise, keep working.

Iterate Loop

For each todo:

a) Mark in progress

CopyTodoWrite: mark current todo as in_progress

b) Do the work Actually implement it. Write the code, create the files, make the changes.

c) Verify with Agents

After completing work, launch verification agents in parallel:

CopyUse the Task tool to launch both agents in a single message:

Task(subagent_type="iterate:verify", prompt="Verify: Added email validation to signup form. Files changed: src/components/SignupForm.tsx")
Task(subagent_type="iterate:quick-review", prompt="Review: src/components/SignupForm.tsx")

The agents will:

• verify: Run tests, check build, confirm functionality
• quick-review: Scan for bugs, security issues, obvious problems

If agents find issues:

• Fix the issues before marking complete
• Re-run verification after fixes

Sequential fallback (if agents unavailable):

• If there are tests: run them
• If it's a build: run the build
• If it's an API: test the endpoint
• If it compiles/runs: confirm it does

d) Mark complete only when verified

CopyTodoWrite: mark as completed (only after verification passes)

e) Move to next todo immediately Don't stop. Don't ask. Pick the next incomplete todo and start.

Periodic Evaluation

After every 3-5 todos, briefly assess:

• What's working?
• What's blocked?
• Should I adjust the approach?
• Are there new todos to add?

Update the state file's Approach/Notes sections if strategy changes significantly.

Completion

The task is done when:

• All todos are marked complete
• All verifications pass
• The original goal is achieved

When complete:

1. Delete the state file:

Copyrm .claude/iterate/<branch>-<timestamp>.md

1. Provide summary:

Copy## Done

Completed X todos:
- [what was accomplished]
- [what was accomplished]

Verified by:
- [tests passing]
- [build succeeding]
- [etc]

What "Verify" Means

If you can't verify automatically, describe what manual verification would show.

Anti-Patterns (Don't Do These)

• ❌ "Here's what you could do next..." → Just do it
• ❌ "You might want to add tests..." → Add the tests
• ❌ "Consider implementing..." → Implement it
• ❌ Stopping after one file → Keep going
• ❌ Asking "should I continue?" → Yes, continue (unless user interrupts)
• ❌ Marking todo complete without verification → Verify first
• ❌ Forgetting to create state file → Always create it first
• ❌ Not reading state file on resume → Always check for existing session

Token Efficiency

• Don't re-read files you just wrote
• Don't re-explain what you just did
• Stay focused on the current todo
• Brief status updates, not essays

Example Flow

CopyUser: /iterate Add input validation to the signup form

[Check for existing session]
→ No state file found, starting new session

[Initialize]
→ Create .claude/iterate/main-20260113-213000.md
→ Goal: Add input validation to the signup form
→ Approach: Add client-side validation with error display

[Decompose]
TodoWrite:
- [ ] Read current signup form code
- [ ] Add email format validation
- [ ] Add password strength validation
- [ ] Add form error display
- [ ] Add tests for validation

[Iterate]
→ Mark "Read current signup form code" in_progress
→ Read the file
→ Mark complete

→ Mark "Add email format validation" in_progress
→ Edit the file, add validation
→ Run tests
→ Tests pass
→ Mark complete

[...continues until all done...]

[Complete]
→ Delete state file
→ Summary:

## Done

Added input validation to signup form:
- Email format validation (regex + error message)
- Password strength (min 8 chars, requires number)
- Error display component
- 4 new tests, all passing

Verified: `npm test` passes, form rejects invalid input

Resuming After Compaction

If context was compacted and you're resuming:

CopyUser: /iterate

[Check for existing session]
→ Found .claude/iterate/main-20260113-213000.md
→ Read state file: Goal is "Add input validation to signup form"
→ Check TodoWrite: 2 of 5 todos complete

Resuming iterate session.
Goal: Add input validation to the signup form
Progress: 2 of 5 todos complete

[Continue from next incomplete todo]
→ Mark "Add password strength validation" in_progress
→ ...

Remember

You are not an assistant making suggestions. You are an executor completing a task. Keep working until it's done or the user stops you.

The state file is your memory. Create it at the start, read it on resume, delete it when done.