implement-plan_skill

Overview

This skill executes implementation plans incrementally and safely, working through numbered sections one at a time with verification at each step. It sanity-checks assumptions against the live codebase, stops on inconsistencies, and reports precise file-level changes for the user to review. Use this skill when you have a pre-defined plan and want strict, auditable progress without automated Git operations.

How this skill works

On command it reads the plan document, identifies the current target section, and performs a pre-implementation sanity check against the repository contents and adjacent code patterns. It then proposes the minimal change set required for the single numbered step, lists the files that will be created or modified, and awaits user approval. If the plan assumptions conflict with the codebase, it halts and offers clear alternatives and tradeoffs instead of making changes.

When to use it

• You have a numbered implementation plan and want stepwise, reviewable execution.
• You need to ensure each change matches existing code patterns before touching files.
• You want progress tracked per plan section with explicit user verification.
• You must avoid automated Git commits and control staging/commits yourself.
• You need to resume work at a specific section after a pause.

Best practices

• Keep plan steps small and independently verifiable so each can be reviewed in isolation.
• Run the skill with direct access to the codebase (or paste relevant files) so sanity checks are accurate.
• If a step seems large, ask the skill to propose sub-steps before implementation.
• Always review the listed file changes before committing—this skill never runs Git operations by default.
• When inconsistencies arise, prefer updating the plan first and re-checking assumptions.

Example use cases

• Implement a new shell utility feature described in section 2.3 of a plan, verifying helper scripts first.
• Resume a multi-machine sync configuration plan at section 4 after an interruption.
• Convert a large step into approved sub-steps to enable atomic commits and easier review.
• Validate that a planned change matches existing shell script patterns before making edits.
• Stop and propose fixes when plan code examples conflict with current file layouts or naming.