Development Process
Executing Plans
Execute implementation plans task-by-task with verification checkpoints, sequential ordering, and frequent commits.
Last reviewed Mar 2, 2026
Install
Create this file in your project:
.claude/skills/executing-plans/SKILL.md---
name: executing-plans
description: Use this skill when given an implementation plan to execute, a list of tasks to complete in order, or when told to follow a plan file.
---
# Executing Plans
## When to Use
- Given a step-by-step implementation plan to follow
- Working through a task list or checklist
- Told to "execute the plan" or "follow these steps"
## Process
1. **Read the entire plan** before starting. Understand the overall goal and how tasks connect.
2. **Verify starting state** -- Run any prerequisite checks (tests pass, app builds, correct branch).
3. **Execute tasks sequentially**. For each task:
a. Read the task description completely.
b. Perform the action exactly as described.
c. Run the verification step specified in the task.
d. If verification fails, stop and debug before continuing.
4. **Commit at checkpoints** -- After each phase or group of related tasks, commit the work.
5. **Report progress** -- After completing each phase, summarize what was done and what's next.
## Rules
- Follow the plan exactly. Do not skip steps, reorder tasks, or add unrequested work.
- If a task is ambiguous, ask for clarification before proceeding. Do not guess.
- If a task fails, stop and fix the issue before moving to the next task. Never skip a failing task.
- Verify after every task, not just at checkpoints.
- Commit working code frequently. Never accumulate more than one phase of uncommitted changes.
- If the plan has errors or outdated information, flag them and propose corrections rather than silently deviating.
- Do not refactor or improve code beyond what the plan specifies.What this skill does
Executing Plans is the counterpart to Writing Plans. While the planning skill produces detailed step-by-step instructions, this skill ensures those instructions are followed faithfully and completely. It enforces sequential execution, verification after each step, and early stopping when something goes wrong.
The discipline of following a plan exactly -- without skipping steps, adding unrequested features, or silently deviating -- is surprisingly difficult for both humans and AI agents. This skill makes that discipline explicit. When a task fails, the agent stops and debugs rather than pressing forward and creating a cascade of errors.
Frequent commits at checkpoint boundaries ensure that progress is saved and that partially completed work can be reviewed. If something goes wrong later, you can always roll back to the last checkpoint without losing everything.
Example workflow
Given a plan file with 12 tasks across 3 phases, the agent will:
- Read all 12 tasks first to understand the full scope.
- Run
npm testandnpm run buildto verify the starting state. - Execute Task 1: create a file, write code, run the specified verification command.
- Execute Task 2, 3, 4 with verification after each.
- At the Phase 1 checkpoint: run the full test suite, commit with a descriptive message.
- Continue to Phase 2, repeating the same discipline.
- After Phase 3, commit final changes and report a summary.
Tips
- Pair this skill with Writing Plans -- use one to create the plan, the other to execute it
- If you need to deviate from the plan, stop and update the plan first, then execute the updated version
- Frequent commits make it safe to experiment -- you can always roll back to the last checkpoint
- This skill works well for onboarding new team members who need to follow established procedures
Best with tools
Related MCP servers
- No linked MCP servers yet.
Related skills
Brainstorming
Collaborative idea-to-design exploration that asks clarifying questions, proposes approaches with tradeoffs, and iterates toward a design.
Systematic Debugging
Enforces a structured debugging workflow: reproduce, hypothesize, verify, fix root cause, and audit similar code paths.
Test-Driven Development
Enforces the red-green-refactor cycle so every feature starts with a failing test before any implementation code is written.