TodoWrite Orchestration

Version: 1.0.0 Purpose: Patterns for using TodoWrite in complex multi-phase workflows Status: Production Ready

Overview

TodoWrite orchestration is the practice of using the TodoWrite tool to provide real-time progress visibility in complex multi-phase workflows. It transforms opaque "black box" workflows into transparent, trackable processes where users can see:

•What phase is currently executing
•How many phases remain
•Which tasks are pending, in-progress, or completed
•Overall progress percentage
•Iteration counts in loops

This skill provides battle-tested patterns for:

•Phase initialization (create complete task list before starting)
•Task granularity (how to break phases into trackable tasks)
•Status transitions (pending → in_progress → completed)
•Real-time updates (mark complete immediately, not batched)
•Iteration tracking (progress through loops)
•Parallel task tracking (multiple agents executing simultaneously)

TodoWrite orchestration is especially valuable for workflows with >5 phases or >10 minutes duration, where users need progress feedback.

Core Patterns

Pattern 1: Phase Initialization

Create TodoWrite List BEFORE Starting:

Initialize TodoWrite as step 0 of your workflow, before any actual work begins:

code

✅ CORRECT - Initialize First:

Step 0: Initialize TodoWrite
  TodoWrite: Create task list
    - PHASE 1: Gather user inputs
    - PHASE 1: Validate inputs
    - PHASE 2: Select AI models
    - PHASE 2: Estimate costs
    - PHASE 2: Get user approval
    - PHASE 3: Launch parallel reviews
    - PHASE 3: Wait for all reviews
    - PHASE 4: Consolidate reviews
    - PHASE 5: Present results

Step 1: Start actual work (PHASE 1)
  Mark "PHASE 1: Gather user inputs" as in_progress
  ... do work ...
  Mark "PHASE 1: Gather user inputs" as completed
  Mark "PHASE 1: Validate inputs" as in_progress
  ... do work ...

❌ WRONG - Create During Workflow:

Step 1: Do some work
  ... work happens ...
  TodoWrite: Create task "Did some work" (completed)

Step 2: Do more work
  ... work happens ...
  TodoWrite: Create task "Did more work" (completed)

Problem: User has no visibility into upcoming phases

List All Phases Upfront:

When initializing, include all phases in the task list, not just the current phase:

code

✅ CORRECT - Complete Visibility:

TodoWrite Initial State:
  [ ] PHASE 1: Gather user inputs
  [ ] PHASE 1: Validate inputs
  [ ] PHASE 2: Architecture planning
  [ ] PHASE 3: Implementation
  [ ] PHASE 3: Run quality checks
  [ ] PHASE 4: Code review
  [ ] PHASE 5: User acceptance
  [ ] PHASE 6: Generate report

User sees: "8 tasks total, 0 complete, Phase 1 starting"

❌ WRONG - Incremental Discovery:

TodoWrite Initial State:
  [ ] PHASE 1: Gather user inputs
  [ ] PHASE 1: Validate inputs

(User thinks workflow is 2 tasks, then surprised by 6 more phases)

Why Initialize First:

•User expectation setting: User knows workflow scope (8 phases, ~20 minutes)
•Progress visibility: User can see % complete (3/8 = 37.5%)
•Time estimation: User can estimate remaining time based on progress
•Transparency: No hidden phases or surprises

Pattern 2: Task Granularity Guidelines

One Task Per Significant Operation:

Each task should represent a significant operation (1-5 minutes of work):

code

✅ CORRECT - Significant Operations:

Tasks:
  - PHASE 1: Ask user for inputs (30s)
  - PHASE 2: Generate architecture plan (2 min)
  - PHASE 3: Implement feature (5 min)
  - PHASE 4: Run tests (1 min)
  - PHASE 5: Code review (3 min)

Each task = meaningful unit of work

❌ WRONG - Too Granular:

Tasks:
  - PHASE 1: Ask user question 1
  - PHASE 1: Ask user question 2
  - PHASE 1: Ask user question 3
  - PHASE 2: Read file A
  - PHASE 2: Read file B
  - PHASE 2: Write file C
  - ... (50 micro-tasks)

Problem: Too many updates, clutters user interface

Multi-Step Phases: Break Into 2-3 Sub-Tasks:

For complex phases (>5 minutes), break into 2-3 sub-tasks:

code

✅ CORRECT - Sub-Task Breakdown:

PHASE 3: Implementation (15 min total)
  → Sub-tasks:
    - PHASE 3: Implement core logic (5 min)
    - PHASE 3: Add error handling (3 min)
    - PHASE 3: Write tests (7 min)

User sees progress within phase: "PHASE 3: 2/3 complete"

❌ WRONG - Single Monolithic Task:

PHASE 3: Implementation (15 min)
  → No sub-tasks

Problem: User sees "in_progress" for 15 min with no updates

Avoid Too Many Tasks:

Limit to max 15-20 tasks for readability:

code

✅ CORRECT - 12 Tasks (readable):

10-phase workflow:
  - PHASE 1: Ask user
  - PHASE 2: Plan (2 sub-tasks)
  - PHASE 3: Implement (3 sub-tasks)
  - PHASE 4: Test
  - PHASE 5: Review (2 sub-tasks)
  - PHASE 6: Fix issues
  - PHASE 7: Re-review
  - PHASE 8: Accept

Total: 12 tasks (clean, trackable)

❌ WRONG - 50 Tasks (overwhelming):

Every single action as separate task:
  - Read file 1
  - Read file 2
  - Write file 3
  - Run command 1
  - ... (50 tasks)

Problem: User overwhelmed, can't see forest for trees

Guideline by Workflow Duration:

code

Workflow Duration → Task Count:

< 5 minutes:    3-5 tasks
5-15 minutes:   8-12 tasks
15-30 minutes:  12-18 tasks
> 30 minutes:   15-20 tasks (if more, group into phases)

Example:
  5-minute workflow (3 phases):
    - PHASE 1: Prepare
    - PHASE 2: Execute
    - PHASE 3: Present
  Total: 3 tasks ✓

  20-minute workflow (6 phases):
    - PHASE 1: Ask user
    - PHASE 2: Plan (2 sub-tasks)
    - PHASE 3: Implement (3 sub-tasks)
    - PHASE 4: Test
    - PHASE 5: Review (2 sub-tasks)
    - PHASE 6: Accept
  Total: 11 tasks ✓

Pattern 3: Status Transitions

Exactly ONE Task In Progress at a Time:

Maintain the invariant: exactly one task in_progress at any moment:

code

✅ CORRECT - One In-Progress:

State at time T1:
  [✓] PHASE 1: Ask user (completed)
  [✓] PHASE 2: Plan (completed)
  [→] PHASE 3: Implement (in_progress)  ← Only one
  [ ] PHASE 4: Test (pending)
  [ ] PHASE 5: Review (pending)

State at time T2 (after PHASE 3 completes):
  [✓] PHASE 1: Ask user (completed)
  [✓] PHASE 2: Plan (completed)
  [✓] PHASE 3: Implement (completed)
  [→] PHASE 4: Test (in_progress)  ← Only one
  [ ] PHASE 5: Review (pending)

❌ WRONG - Multiple In-Progress:

State:
  [✓] PHASE 1: Ask user (completed)
  [→] PHASE 2: Plan (in_progress)  ← Two in-progress?
  [→] PHASE 3: Implement (in_progress)  ← Confusing!
  [ ] PHASE 4: Test (pending)

Problem: User confused about current phase

Status Transition Sequence:

code

Lifecycle of a Task:

1. Created: pending
   (Task exists, not started yet)

2. Started: pending → in_progress
   (Mark as in_progress when starting work)

3. Completed: in_progress → completed
   (Mark as completed immediately after finishing)

4. Next task: Mark next task as in_progress
   (Continue to next task)

Example Timeline:

T=0s:  [→] Task 1 (in_progress), [ ] Task 2 (pending)
T=30s: [✓] Task 1 (completed),   [→] Task 2 (in_progress)
T=60s: [✓] Task 1 (completed),   [✓] Task 2 (completed)

NEVER Batch Completions:

Mark tasks completed immediately after finishing, not at end of phase:

code

✅ CORRECT - Immediate Updates:

Mark "PHASE 1: Ask user" as in_progress
... do work (30s) ...
Mark "PHASE 1: Ask user" as completed  ← Immediate

Mark "PHASE 1: Validate inputs" as in_progress
... do work (20s) ...
Mark "PHASE 1: Validate inputs" as completed  ← Immediate

User sees real-time progress

❌ WRONG - Batched Updates:

Mark "PHASE 1: Ask user" as in_progress
... do work (30s) ...

Mark "PHASE 1: Validate inputs" as in_progress
... do work (20s) ...

(At end of PHASE 1, batch update both to completed)

Problem: User doesn't see progress for 50s, thinks workflow is stuck

Pattern 4: Real-Time Progress Tracking

Update TodoWrite As Work Progresses:

TodoWrite should reflect current state, not past state:

code

✅ CORRECT - Real-Time Updates:

T=0s:  Initialize TodoWrite (8 tasks, all pending)
T=5s:  Mark "PHASE 1" as in_progress
T=35s: Mark "PHASE 1" as completed, "PHASE 2" as in_progress
T=90s: Mark "PHASE 2" as completed, "PHASE 3" as in_progress
...

User always sees accurate current state

❌ WRONG - Delayed Updates:

T=0s:   Initialize TodoWrite
T=300s: Workflow completes
T=301s: Update all tasks to completed

Problem: No progress visibility for 5 minutes

Add New Tasks If Discovered During Execution:

If you discover additional work during execution, add new tasks:

code

Scenario: During implementation, realize refactoring needed

Initial TodoWrite:
  [✓] PHASE 1: Plan
  [→] PHASE 2: Implement
  [ ] PHASE 3: Test
  [ ] PHASE 4: Review

During PHASE 2, discover:
  "Implementation requires refactoring legacy code"

Updated TodoWrite:
  [✓] PHASE 1: Plan
  [✓] PHASE 2: Implement core logic (completed)
  [→] PHASE 2: Refactor legacy code (in_progress)  ← New task added
  [ ] PHASE 3: Test
  [ ] PHASE 4: Review

User sees: "Additional work discovered: refactoring. Total now 5 tasks."

User Can See Current Progress at Any Time:

With real-time updates, user can check progress:

code

User checks at T=120s:

TodoWrite State:
  [✓] PHASE 1: Ask user
  [✓] PHASE 2: Plan architecture
  [→] PHASE 3: Implement core logic (in_progress)
  [ ] PHASE 3: Add error handling
  [ ] PHASE 3: Write tests
  [ ] PHASE 4: Code review
  [ ] PHASE 5: Accept

User sees: "3/8 tasks complete (37.5%), currently implementing core logic"

Pattern 5: Iteration Loop Tracking

Create Task Per Iteration:

For iteration loops, create a task for each iteration:

code

✅ CORRECT - Iteration Tasks:

Design Validation Loop (max 10 iterations):

Initial TodoWrite:
  [ ] Iteration 1/10: Designer validation
  [ ] Iteration 2/10: Designer validation
  [ ] Iteration 3/10: Designer validation
  ... (create all 10 upfront)

Progress:
  [✓] Iteration 1/10: Designer validation (NEEDS IMPROVEMENT)
  [✓] Iteration 2/10: Designer validation (NEEDS IMPROVEMENT)
  [→] Iteration 3/10: Designer validation (in_progress)
  [ ] Iteration 4/10: Designer validation
  ...

User sees: "Iteration 3/10 in progress, 2 complete"

❌ WRONG - Single Loop Task:

TodoWrite:
  [→] Design validation loop (in_progress)

Problem: User sees "in_progress" for 10 minutes, no iteration visibility

Mark Iteration Complete When Done:

code

Iteration Lifecycle:

Iteration 1:
  Mark "Iteration 1/10" as in_progress
  Run designer validation
  If NEEDS IMPROVEMENT: Run developer fixes
  Mark "Iteration 1/10" as completed

Iteration 2:
  Mark "Iteration 2/10" as in_progress
  Run designer validation
  If PASS: Exit loop early
  Mark "Iteration 2/10" as completed

Result: Loop exited after 2 iterations
  [✓] Iteration 1/10 (completed)
  [✓] Iteration 2/10 (completed)
  [ ] Iteration 3/10 (not needed, loop exited)
  ...

User sees: "Loop completed in 2/10 iterations"

Track Total Iterations vs Max Limit:

code

Iteration Progress:

Max: 10 iterations
Current: 5

TodoWrite State:
  [✓] Iteration 1/10
  [✓] Iteration 2/10
  [✓] Iteration 3/10
  [✓] Iteration 4/10
  [→] Iteration 5/10
  [ ] Iteration 6/10
  ...

User sees: "Iteration 5/10 (50% through max)"

Warning at Iteration 8:
  "Iteration 8/10 - approaching max, may escalate to user if not PASS"

Clear Progress Visibility:

code

Iteration Loop with TodoWrite:

User Request: "Validate UI design"

TodoWrite:
  [✓] PHASE 1: Gather design reference
  [✓] Iteration 1/10: Designer validation (5 issues found)
  [✓] Iteration 2/10: Designer validation (3 issues found)
  [✓] Iteration 3/10: Designer validation (1 issue found)
  [→] Iteration 4/10: Designer validation (in_progress)
  [ ] Iteration 5/10: Designer validation
  ...
  [ ] PHASE 3: User validation gate

User sees:
  - 4 iterations completed (40% through max)
  - Issues reducing each iteration (5 → 3 → 1)
  - Progress toward PASS

Pattern 6: Parallel Task Tracking

Multiple Agents Executing Simultaneously:

When running agents in parallel, track each separately:

code

✅ CORRECT - Separate Tasks for Parallel Agents:

Multi-Model Review (3 models in parallel):

TodoWrite:
  [✓] PHASE 1: Prepare review context
  [→] PHASE 2: Claude review (in_progress)
  [→] PHASE 2: Grok review (in_progress)
  [→] PHASE 2: Gemini review (in_progress)
  [ ] PHASE 3: Consolidate reviews

Note: 3 tasks "in_progress" is OK for parallel execution
      (Exception to "one in_progress" rule)

As models complete:
  [✓] PHASE 1: Prepare review context
  [✓] PHASE 2: Claude review (completed)  ← First to finish
  [→] PHASE 2: Grok review (in_progress)
  [→] PHASE 2: Gemini review (in_progress)
  [ ] PHASE 3: Consolidate reviews

User sees: "1/3 reviews complete, 2 in progress"

❌ WRONG - Single Task for Parallel Work:

TodoWrite:
  [✓] PHASE 1: Prepare
  [→] PHASE 2: Run 3 reviews (in_progress)
  [ ] PHASE 3: Consolidate

Problem: No visibility into which reviews are complete

Update As Each Agent Completes:

code

Parallel Execution Timeline:

T=0s:  Launch 3 reviews in parallel
  [→] Claude review (in_progress)
  [→] Grok review (in_progress)
  [→] Gemini review (in_progress)

T=60s: Claude completes first
  [✓] Claude review (completed)
  [→] Grok review (in_progress)
  [→] Gemini review (in_progress)

T=120s: Gemini completes
  [✓] Claude review (completed)
  [→] Grok review (in_progress)
  [✓] Gemini review (completed)

T=180s: Grok completes
  [✓] Claude review (completed)
  [✓] Grok review (completed)
  [✓] Gemini review (completed)

User sees real-time completion updates

Progress Indicators During Long Parallel Tasks:

code

For long-running parallel tasks (>2 minutes), show progress:

T=0s:   "Launching 5 AI model reviews (estimated 5 minutes)..."
T=60s:  "1/5 reviews complete..."
T=120s: "2/5 reviews complete..."
T=180s: "4/5 reviews complete, 1 in progress..."
T=240s: "All reviews complete! Consolidating results..."

TodoWrite mirrors this:
  [✓] Claude review (1/5 complete)
  [✓] Grok review (2/5 complete)
  [→] Gemini review (in_progress)
  [→] GPT-5 review (in_progress)
  [→] DeepSeek review (in_progress)

Integration with Other Skills

todowrite-orchestration + multi-agent-coordination:

code

Use Case: Multi-phase implementation workflow

Step 1: Initialize TodoWrite (todowrite-orchestration)
  Create task list for all 8 phases

Step 2: Sequential Agent Delegation (multi-agent-coordination)
  Phase 1: api-architect
    Mark PHASE 1 as in_progress
    Delegate to api-architect
    Mark PHASE 1 as completed

  Phase 2: backend-developer
    Mark PHASE 2 as in_progress
    Delegate to backend-developer
    Mark PHASE 2 as completed

  ... continue for all phases

todowrite-orchestration + multi-model-validation:

code

Use Case: Multi-model review with progress tracking

Step 1: Initialize TodoWrite (todowrite-orchestration)
  [ ] PHASE 1: Prepare context
  [ ] PHASE 2: Launch reviews (5 models)
  [ ] PHASE 3: Consolidate results

Step 2: Parallel Execution (multi-model-validation)
  Mark "PHASE 2: Launch reviews" as in_progress
  Launch all 5 models simultaneously
  As each completes: Update progress (1/5, 2/5, ...)
  Mark "PHASE 2: Launch reviews" as completed

Step 3: Real-Time Visibility (todowrite-orchestration)
  User sees: "PHASE 2: 3/5 reviews complete..."

todowrite-orchestration + quality-gates:

code

Use Case: Iteration loop with TodoWrite tracking

Step 1: Initialize TodoWrite (todowrite-orchestration)
  [ ] Iteration 1/10
  [ ] Iteration 2/10
  ...

Step 2: Iteration Loop (quality-gates)
  For i = 1 to 10:
    Mark "Iteration i/10" as in_progress
    Run designer validation
    If PASS: Exit loop
    Mark "Iteration i/10" as completed

Step 3: Progress Visibility
  User sees: "Iteration 5/10 complete, 5 remaining"

Best Practices

Do:

•✅ Initialize TodoWrite BEFORE starting work (step 0)
•✅ List ALL phases upfront (user sees complete scope)
•✅ Use 8-15 tasks for typical workflows (readable)
•✅ Mark completed IMMEDIATELY after finishing (real-time)
•✅ Keep exactly ONE task in_progress (except parallel tasks)
•✅ Track iterations separately (Iteration 1/10, 2/10, ...)
•✅ Update as work progresses (not batched at end)
•✅ Add new tasks if discovered during execution

Don't:

•❌ Create TodoWrite during workflow (initialize first)
•❌ Hide phases from user (list all upfront)
•❌ Create too many tasks (>20 overwhelms user)
•❌ Batch completions at end of phase (update real-time)
•❌ Leave multiple tasks in_progress (pick one)
•❌ Use single task for loop (track iterations separately)
•❌ Update only at start/end (update during execution)

Performance:

•TodoWrite overhead: <1s per update (negligible)
•User visibility benefit: Reduces perceived wait time 30-50%
•Workflow confidence: User knows progress, less likely to cancel

Examples

Example 1: 8-Phase Implementation Workflow

Scenario: Full-cycle implementation with TodoWrite tracking

Execution:

code

Step 0: Initialize TodoWrite
  TodoWrite: Create task list
    [ ] PHASE 1: Ask user for requirements
    [ ] PHASE 2: Generate architecture plan
    [ ] PHASE 3: Implement core logic
    [ ] PHASE 3: Add error handling
    [ ] PHASE 3: Write tests
    [ ] PHASE 4: Run test suite
    [ ] PHASE 5: Code review
    [ ] PHASE 6: Fix review issues
    [ ] PHASE 7: User acceptance
    [ ] PHASE 8: Generate report

  User sees: "10 tasks, 0 complete, Phase 1 starting..."

Step 1: PHASE 1
  Mark "PHASE 1: Ask user" as in_progress
  ... gather requirements (30s) ...
  Mark "PHASE 1: Ask user" as completed
  User sees: "1/10 tasks complete (10%)"

Step 2: PHASE 2
  Mark "PHASE 2: Architecture plan" as in_progress
  ... generate plan (2 min) ...
  Mark "PHASE 2: Architecture plan" as completed
  User sees: "2/10 tasks complete (20%)"

Step 3: PHASE 3 (3 sub-tasks)
  Mark "PHASE 3: Implement core" as in_progress
  ... implement (3 min) ...
  Mark "PHASE 3: Implement core" as completed
  User sees: "3/10 tasks complete (30%)"

  Mark "PHASE 3: Add error handling" as in_progress
  ... add error handling (2 min) ...
  Mark "PHASE 3: Add error handling" as completed
  User sees: "4/10 tasks complete (40%)"

  Mark "PHASE 3: Write tests" as in_progress
  ... write tests (3 min) ...
  Mark "PHASE 3: Write tests" as completed
  User sees: "5/10 tasks complete (50%)"

... continue through all phases ...

Final State:
  [✓] All 10 tasks completed
  User sees: "10/10 tasks complete (100%). Workflow finished!"

Total Duration: ~15 minutes
User Experience: Continuous progress updates every 1-3 minutes

Example 2: Iteration Loop with Progress Tracking

Scenario: Design validation with 10 max iterations

Execution:

code

Step 0: Initialize TodoWrite
  TodoWrite: Create task list
    [ ] PHASE 1: Gather design reference
    [ ] Iteration 1/10: Designer validation
    [ ] Iteration 2/10: Designer validation
    [ ] Iteration 3/10: Designer validation
    [ ] Iteration 4/10: Designer validation
    [ ] Iteration 5/10: Designer validation
    ... (10 iterations total)
    [ ] PHASE 3: User validation gate

Step 1: PHASE 1
  Mark "PHASE 1: Gather design" as in_progress
  ... gather design (20s) ...
  Mark "PHASE 1: Gather design" as completed

Step 2: Iteration Loop
  Iteration 1:
    Mark "Iteration 1/10" as in_progress
    Designer: "NEEDS IMPROVEMENT - 5 issues"
    Developer: Fix 5 issues
    Mark "Iteration 1/10" as completed
    User sees: "Iteration 1/10 complete, 5 issues fixed"

  Iteration 2:
    Mark "Iteration 2/10" as in_progress
    Designer: "NEEDS IMPROVEMENT - 3 issues"
    Developer: Fix 3 issues
    Mark "Iteration 2/10" as completed
    User sees: "Iteration 2/10 complete, 3 issues fixed"

  Iteration 3:
    Mark "Iteration 3/10" as in_progress
    Designer: "NEEDS IMPROVEMENT - 1 issue"
    Developer: Fix 1 issue
    Mark "Iteration 3/10" as completed
    User sees: "Iteration 3/10 complete, 1 issue fixed"

  Iteration 4:
    Mark "Iteration 4/10" as in_progress
    Designer: "PASS ✓"
    Mark "Iteration 4/10" as completed
    Exit loop (early exit)
    User sees: "Loop completed in 4/10 iterations"

Step 3: PHASE 3
  Mark "PHASE 3: User validation" as in_progress
  ... user validates ...
  Mark "PHASE 3: User validation" as completed

Final State:
  [✓] PHASE 1: Gather design
  [✓] Iteration 1/10 (5 issues fixed)
  [✓] Iteration 2/10 (3 issues fixed)
  [✓] Iteration 3/10 (1 issue fixed)
  [✓] Iteration 4/10 (PASS)
  [ ] Iteration 5/10 (not needed)
  ...
  [✓] PHASE 3: User validation

User Experience: Clear iteration progress, early exit visible

Example 3: Parallel Multi-Model Review

Scenario: 5 AI models reviewing code in parallel

Execution:

code

Step 0: Initialize TodoWrite
  TodoWrite: Create task list
    [ ] PHASE 1: Prepare review context
    [ ] PHASE 2: Claude review
    [ ] PHASE 2: Grok review
    [ ] PHASE 2: Gemini review
    [ ] PHASE 2: GPT-5 review
    [ ] PHASE 2: DeepSeek review
    [ ] PHASE 3: Consolidate reviews
    [ ] PHASE 4: Present results

Step 1: PHASE 1
  Mark "PHASE 1: Prepare context" as in_progress
  ... prepare (30s) ...
  Mark "PHASE 1: Prepare context" as completed

Step 2: PHASE 2 (Parallel Execution)
  Mark all 5 reviews as in_progress:
    [→] Claude review
    [→] Grok review
    [→] Gemini review
    [→] GPT-5 review
    [→] DeepSeek review

  Launch all 5 in parallel (4-Message Pattern)

  As each completes:
    T=60s:  Claude completes
      [✓] Claude review
      User sees: "1/5 reviews complete"

    T=90s:  Gemini completes
      [✓] Gemini review
      User sees: "2/5 reviews complete"

    T=120s: GPT-5 completes
      [✓] GPT-5 review
      User sees: "3/5 reviews complete"

    T=150s: Grok completes
      [✓] Grok review
      User sees: "4/5 reviews complete"

    T=180s: DeepSeek completes
      [✓] DeepSeek review
      User sees: "5/5 reviews complete!"

Step 3: PHASE 3
  Mark "PHASE 3: Consolidate" as in_progress
  ... consolidate (30s) ...
  Mark "PHASE 3: Consolidate" as completed

Step 4: PHASE 4
  Mark "PHASE 4: Present results" as in_progress
  ... present (10s) ...
  Mark "PHASE 4: Present results" as completed

Final State:
  [✓] All 8 tasks completed
  User sees: "Multi-model review complete in 3 minutes"

User Experience:
  - Real-time progress as each model completes
  - Clear visibility: "3/5 reviews complete"
  - Reduces perceived wait time (user knows progress)

Troubleshooting

Problem: User thinks workflow is stuck

Cause: No TodoWrite updates for >1 minute

Solution: Update TodoWrite more frequently, or add sub-tasks

code

❌ Wrong:
  [→] PHASE 3: Implementation (in_progress for 10 minutes)

✅ Correct:
  [✓] PHASE 3: Implement core logic (2 min)
  [✓] PHASE 3: Add error handling (3 min)
  [→] PHASE 3: Write tests (in_progress, 2 min so far)

User sees progress every 2-3 minutes

Problem: Too many tasks (>20), overwhelming

Cause: Too granular task breakdown

Solution: Group micro-tasks into larger operations

code

❌ Wrong (25 tasks):
  [ ] Read file 1
  [ ] Read file 2
  [ ] Write file 3
  ... (25 micro-tasks)

✅ Correct (8 tasks):
  [ ] PHASE 1: Gather inputs (includes reading files)
  [ ] PHASE 2: Process data
  ... (8 significant operations)

Problem: Multiple tasks "in_progress" (not parallel execution)

Cause: Forgot to mark previous task as completed

Solution: Always mark completed before starting next

code

❌ Wrong:
  [→] PHASE 1: Ask user (in_progress)
  [→] PHASE 2: Plan (in_progress)  ← Both in_progress?

✅ Correct:
  [✓] PHASE 1: Ask user (completed)
  [→] PHASE 2: Plan (in_progress)  ← Only one

Summary

TodoWrite orchestration provides real-time progress visibility through:

•Phase initialization (create task list before starting)
•Appropriate granularity (8-15 tasks, significant operations)
•Real-time updates (mark completed immediately)
•Exactly one in_progress (except parallel execution)
•Iteration tracking (separate task per iteration)
•Parallel task tracking (update as each completes)

Master these patterns and users will always know:

•What's happening now
•What's coming next
•How much progress has been made
•How much remains

This transforms "black box" workflows into transparent, trackable processes.

Extracted From:

•/review command (10-task initialization, phase-based tracking)
•/implement command (8-phase workflow with sub-tasks)
•/validate-ui command (iteration tracking, user feedback rounds)
•All multi-phase orchestration workflows