Adaptive Two-Phase Planning Workflow

When this skill activates, follow ADR 0008's workflow pattern:

Phase 1: Initial Planning (Plan Mode)

1. •

   Explore the codebase

   • •Use Task tool with Explore subagent for thorough analysis
   • •Identify relevant files, patterns, and dependencies
   • •Understand current architecture and constraints
2. •

   Create a roadmap using TodoWrite:

   • •Break feature into logical subtasks
   • •Identify dependencies between tasks
   • •Note expected complexity for each
   • •Order tasks to respect dependencies
3. •

   Present plan to user:

   • •Show TodoWrite roadmap
   • •Explain overall approach
   • •Highlight key architectural decisions
   • •Note any potential risks or unknowns
4. •

   Wait for approval before proceeding

5. •

   Exit Plan Mode after approval

   • •Inform user you're ready to begin implementation
   • •Confirm they want to proceed

Phase 2: Per-Task Execution with Re-assessment

For each subtask sequentially:

Step 1: Pre-Implementation Check

Before implementing each task:

1. •

   Re-assess current codebase state

   • •Has anything changed from previous tasks?
   • •Do previous implementations affect this task?
   • •Are there better approaches now visible?
2. •

   Choose explanation path:

   • •

     Quick path (if state matches plan):

     • •"Proceeding with planned approach: [1-2 sentence summary]"
     • •Brief reminder of what you'll do
   • •

     Detailed path (if diverging from plan):

     • •Explain what changed in codebase state
     • •Describe how this affects the approach
     • •Propose adjusted implementation strategy
     • •Explain why the adjustment is better
3. •

   Wait for explicit user approval if:

   • •Approach diverges from original plan
   • •Task is complex or risky
   • •Previous task revealed unexpected complexity

   For simple tasks matching plan, brief confirmation is sufficient.

Step 2: Implementation

1. •Mark task as in_progress in TodoWrite
2. •Implement the code
   • •Follow approved approach
   • •Write clean, maintainable code
   • •Avoid security vulnerabilities (XSS, injection, etc.)
3. •Update TodoWrite as completed immediately after finishing

Step 3: Post-Implementation Summary

After completing implementation:

1. •

   Summarize what was done:

   • •Key changes made
   • •Files modified
   • •Any deviations from planned approach (and why)
2. •

   Show overall impact:

   • •How this task advances the feature
   • •What's now ready for the next task
3. •

   Wait for explicit user approval before moving to next task

Step 4: Commit Reminder (CRITICAL)

NEVER attempt to commit code. This skill CANNOT access git commands.

After user approves changes:

1. •Remind user: "Ready to commit? Please run /commit when you're ready to commit these changes."
2. •Wait for user to explicitly run the /commit command
3. •Do NOT proceed to next task until user has committed (or explicitly says to continue without committing)

Step 5: Suggest Next Step

1. •Recommend next subtask from roadmap
2. •Note any adjustments needed based on what was learned
3. •Wait for approval to proceed

Optimization Rules

• •Quick approval for straightforward tasks: If everything matches plan and is simple, brief confirmation is enough
• •Detailed discussion for divergence: If discovered complexity, better approach, or changed assumptions, explain thoroughly
• •Always wait for approval: Before implementation starts and before suggesting commits
• •One task at a time: Complete current task fully before starting next
• •Adaptive, not rigid: Treat initial plan as roadmap, not contract - adapt when reality differs
• •NO COMMITS EVER: This skill cannot and will not make commits - user must explicitly run /commit

Integration Points

• •Uses Plan Mode for Phase 1 exploration (read-only safety)
• •Uses Task tool with Explore subagent for thorough codebase analysis
• •Uses TodoWrite for task tracking and roadmap management
• •Coordinates with /reassess command for explicit re-assessment
• •User runs /commit command for approval-gated commits
• •Respects approval hooks if configured