Developer pack
Claude Skill
Implementation Plan Executor
Works through a written implementation plan task-by-task — review it first, execute each step, verify, commit — with checkpoints.
What it does
Takes an existing implementation plan and executes it deliberately: reviews the whole plan critically and raises concerns before starting, then works task by task, running the specified verification after each and committing per task. The disciplined execution half that pairs with a plan from the execution-plan-writer.
When to use
- ✓You have a written plan and need it implemented carefully, not improvised
- ✓A multi-task change where skipping steps causes drift
- ✓You want verification and a commit per task, not one big dump at the end
When not to use
- ✗There's no plan yet — write one first
- ✗A one-step change that needs no sequencing
Install
Download the .zip, then unzip into your Claude skills folder.
mkdir -p ~/.claude/skills
unzip ~/Downloads/implementation-plan-executor.zip -d ~/.claude/skills/
# Restart Claude Code session.
# Skill is now available — Claude will use it when relevant.SKILL.md
SKILL.md
---
name: implementation-plan-executor
description: Use when you have a written implementation plan to execute with review checkpoints. Triggers on "execute this plan", "work through the plan", "implement this plan task by task", "follow the migration plan".
---
# Implementation Plan Executor
Execute a written plan deliberately: review it, work task by task, verify each step, and commit as you go. The discipline is what keeps a long change from drifting off the plan into improvised scope.
## Step 1 — Load and review critically
Read the whole plan first. Before executing anything, look for problems: gaps, wrong assumptions, steps that won't work in this codebase, missing context. If you have concerns, raise them and resolve them before starting — don't dutifully execute a plan you can already see is flawed.
## Step 2 — Execute task by task
Work one task at a time, in order. Follow each bite-sized step as written, run the verification the plan specifies (the test, the check) before moving on, and keep visible track of what's in progress vs done. Don't batch several tasks together — the per-task verification is the safety net.
## Step 3 — Commit per task
Commit each completed, verified task. Frequent commits keep the history legible and make it cheap to back out a single step if it turns out wrong.
## Step 4 — Finish properly
When all tasks are done and verified, finish the branch deliberately — run the suite and integrate (merge or PR). "Plan executed" isn't done until the work is tested and integrated.
## When reality diverges from the plan
If a task can't be done as written, or you discover the plan was wrong, stop and flag it — don't silently expand scope or improvise a different design. Update the plan, then continue.
## Anti-patterns
- Executing a plan whose problems you already spotted, without raising them
- Skipping the per-task verification to go faster
- Batching many tasks into one commit
- Silently expanding scope beyond the plan
- Calling it done without running the final checks
Example prompts
Once installed, try these prompts in Claude:
- Here's the implementation plan. Review it for problems, then execute it task by task, verifying and committing each.
- Work through this migration plan one step at a time — don't skip the verification between tasks.