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:

✅ 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:

✅ 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):

✅ 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:

✅ 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:

✅ 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:

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:

✅ 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:

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:

✅ 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:

✅ 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:

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:

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:

✅ 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:

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:

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:

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:

✅ 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:

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:

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:

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:

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:

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:

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:

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:

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

❌ 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

❌ 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

❌ 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