plan-executor

---

name: plan-executor description: Execute an outlined plan step by step, tracking progress and updating the status of each step as you go. Use this skill whenever you need to execute an outlined plan.

The capabilities section describes the key capabilities for executing plans effectively.

Note: Detailed execution examples are available in separate files to reduce context size. Load only the specific example you need.

Available Examples:

• Single-Component Refactor: Simple 8-step refactor with progress updates
  • Load: examples/single-component-refactor.md
• Multi-File Feature Implementation: Complex 15-step implementation across multiple files
  • Load: examples/multi-file-implementation.md
• Handling Failed Steps: Error recovery and debugging during execution
  • Load: examples/handling-failed-steps.md

When to load: Load a specific example when you need concrete guidance for a similar scenario.

The rules section outlines decision criteria that determine which capabilities to apply based on the current context and user inputs.

At Plan Start: Apply the plan-tracking capability to initialize the tracking system with all plan steps before beginning execution.

During Execution: Apply the step-execution capability continuously:

• Before each step: think aloud and explain your approach
• During each step: execute thoroughly and handle dependencies
• After each step: validate results and update status to completed immediately

For Long or Multi-Phase Plans: Apply the progress-reporting capability:

• After completing major phases (e.g., all tests written, all implementations done)
• After every 8-10 steps for plans with 15+ steps
• When switching contexts (moving to different files/components)
• Always provide a final completion summary at the end

When Steps Fail or Encounter Errors: Apply the error-handling capability immediately:

• Document the error clearly
• Analyze root cause
• Attempt to fix and retry
• If unresolvable, consult the user before proceeding
• Never skip failed validation steps

At Validation Points: Apply the validation-checkpoints capability:

• After code changes: run relevant tests
• After significant changes: run linting, formatting, type-checking
• At major milestones: verify builds succeed
• Don't wait until the end—validate incrementally throughout execution

When Facing Ambiguity or Blockers: Apply the user-interaction capability:

• If a step is unclear: pause and ask for clarification
• If external dependencies are missing: document the blocker and consult the user
• If deviations from the plan are necessary: explain why and how you're adapting
• Otherwise, execute autonomously without asking for permission at each step

Plan Immutability: Throughout execution, apply the plan-tracking immutability principle—never modify the plan structure, objectives, or steps except to update statuses or add brief clarifying notes. Never skip, reorder, or remove steps without explicit user approval.

Complete All Steps: Execute ALL steps in the plan thoroughly, regardless of the number of steps or files affected. Do not stop early or leave steps partially completed.