25 KiB
25 KiB
name, description, version, tags, keywords
| name | description | version | tags | keywords | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| todowrite-orchestration | Track progress in multi-phase workflows with TodoWrite. Use when orchestrating 5+ phase commands, managing iteration loops, tracking parallel tasks, or providing real-time progress visibility. Trigger keywords - "phase tracking", "progress", "workflow", "multi-step", "multi-phase", "todo", "tracking", "status". | 0.1.0 |
|
|
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:
/reviewcommand (10-task initialization, phase-based tracking)/implementcommand (8-phase workflow with sub-tasks)/validate-uicommand (iteration tracking, user feedback rounds)- All multi-phase orchestration workflows