Skip to main content
skill CX Codex

executing-plans · osmontero — Claude Code skill: plan execution

The executing-plans Claude Code skill carries out a written implementation plan in stages, with checks between batches. It activates when subagents cannot be used or tasks are too coupled to split up.

MIT 107 installs ★ 18 updated 2026-10-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add osmontero/opencode-skills --skill executing-plans -a claude-code
Open on GitHub

What executing-plans does

The skill inspects the plan and workspace before changing code, then works through small task batches. At each checkpoint, it runs the specified checks and reports their output, including any deviations. It stops to ask when a step cannot be completed as written or a check fails twice.

It requires the using-git-worktrees, verifying-before-completion, and finishing-a-development-branch skills. Work must not start on main or master without explicit consent, and the workspace must be clean. At handoff, the skill checks the implementation against the plan.

What it helps with

  • break an implementation plan into task batches
  • catch missing steps and inconsistent references before coding
  • run plan checks at each checkpoint
  • report deviations and stop on blockers

Example prompts for the agent

  • Carry out the plan in implementation-plan.md in batches and report after each checkpoint.
  • Review plan.md for gaps and dependencies, then implement its tasks.
  • Follow the written plan and stop if a step depends on a false assumption about the codebase.

How to install executing-plans

1Skills CLI (Vercel)

npx skills add osmontero/opencode-skills --skill executing-plans -a claude-code

2Manually: put the files in place

~/.claude/skills/executing-plans/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/executing-plans/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about executing-plans

How do I install executing-plans in Claude Code?

Run npx skills add osmontero/opencode-skills --skill executing-plans -a claude-code. The skill file is installed at ~/.claude/skills/executing-plans/SKILL.md.

What does executing-plans do?

It reviews a written plan before implementation, works through tasks in batches, and checks results at checkpoints. It pauses when blocked or when a verification fails twice.

Which skills does executing-plans require?

It requires using-git-worktrees, verifying-before-completion, and finishing-a-development-branch.

Source text

SKILL.md · MIT
---
name: executing-plans
description: Use when you have a written implementation plan to execute in the current session with review checkpoints, and subagents are unavailable or the tasks are too coupled to delegate
compatibility: opencode
---

# Executing Plans

## Overview

Load the plan, review it critically, execute in batches with checkpoints, verify, and hand off.

**Announce at start:** "I'm using the executing-plans skill to implement this plan."

**Prefer subagent-driven-development when you can.** Fresh context per task and staged review (spec, quality, and security for security-relevant tasks) produce measurably better results than inline execution. Use this skill when subagents are unavailable, when tasks are too tightly coupled to isolate, or when the plan is small enough that dispatch overhead exceeds the benefit.

## The Iron Law

```
NO EXECUTION WITHOUT A CRITICAL REVIEW OF THE PLAN FIRST
```

Executing a flawed plan faithfully produces a flawed implementation efficiently. The review is not a formality — it is the only point where a bad plan costs minutes instead of hours.

Started executing without reviewing? Stop and review now. It is cheaper at task 2 than at task 9.

## Checklist

Create a todo for each:

1. **Verify the workspace** — isolated branch or worktree, clean baseline
2. **Load and review the plan critically** — raise concerns before starting
3. **Build the todo list** — one entry per task
4. **Execute in batches** — 2-3 tasks, then checkpoint
5. **Verify at each checkpoint** — run the actual commands
6. **Final verification** — full suite, plan coverage check
7. **Hand off** — finishing-a-development-branch

## Step 1: Verify the Workspace

**REQUIRED SUB-SKILL:** Use using-git-worktrees before starting.

**Never begin implementation on `main`/`master` without explicit consent.** Check first:

```bash
git branch --show-current
git status --porcelain    # must be clean before starting
```

A dirty tree means you cannot tell your changes from pre-existing ones at review time.

## Step 2: Review the Plan Critically

Read the whole plan before writing any code. Check for:

| Check | Red flag |
|---|---|
| **Placeholders** | "TBD", "add error handling", "write tests for the above", "similar to Task 3" |
| **Type consistency** | `clearLayers()` in Task 3, `clearFullLayers()` in Task 7 |
| **Undefined references** | A task uses a type or function no task defines |
| **File paths** | Paths that do not exist and no task creates |
| **Verification** | Steps with no command, or commands with no expected output |
| **Ordering** | Task 5 depends on something Task 8 builds |
| **Scope** | Multiple independent subsystems that should have been separate plans |

**If you find issues:** raise all of them at once, before starting. Do not fix the plan silently and do not discover them one at a time across the session.

```
Reviewed the plan. Three issues before I start:

1. Task 4 calls `validateToken()` — no task defines it. Task 2 defines
   `verifyToken()`. Same function, or a gap?
2. Task 6 modifies `src/auth/session.ts:40-58`; that file is 22 lines.
   The line range is stale.
3. Tasks 8-11 cover the notifications subsystem, independent of auth.
   Split into a second plan?
```

## Step 3: Execute in Batches

Work 2-3 tasks at a time, then checkpoint. Batching keeps momentum without letting errors compound across nine tasks.

For each task:

1. Mark in_progress
2. **Follow the steps exactly** — the plan's granularity is deliberate
3. Run the verification the step specifies and read the output
4. Commit as the plan directs
5. Mark completed

**Follow the plan's steps exactly** means writing the failing test first when the plan says to, and running it to watch it fail before implementing. Skipping the "run it and see it fail" step is the most common way plan execution silently degrades — see test-driven-development.

**Do not batch commits.** Committing per task is what makes a checkpoint reviewable and a mistake revertible.

## Step 4: Checkpoint

After each batch, report and pause:

```
Tasks 1-3 complete.

- Task 1: token verification — 6 tests, all passing
- Task 2: session store — 4 tests, all passing
- Task 3: middleware wiring — 3 tests, all passing

Full suite: 47 passed, 0 failed.
Deviation: Task 2 specified a Map; used a WeakMap so sessions are
garbage-collected with their request objects. Behavior is identical.

Continue with tasks 4-6?
```

Checkpoints report **evidence**, not confidence — actual command output, not "should be working." See verifying-before-completion.

Optionally dispatch a reviewer at each checkpoint — see requesting-code-review. If the batch touched security-relevant code, dispatch the `security-reviewer` and treat Critical or High findings as blocking.

## Step 5: Handling Deviations

Plans meet reality. Classify what happens next:

| Situation | Do |
|---|---|
| Step's code has a typo/obvious small error | Fix it, note it at the checkpoint |
| Step's approach works but a better one exists | Follow the plan. Note the alternative. Do not unilaterally improve. |
| Step is impossible as written | Stop. Report why. Propose an alternative. Wait. |
| Step's assumption about the codebase is wrong | Stop. The plan needs updating, not working around. |
| A task turns out unnecessary | Stop and ask — do not silently skip |
| You discover an unrelated bug | Note it. Do not fix it. Scope creep in execution is how plans lose their meaning. |

**Never silently deviate.** Every deviation is reported at the next checkpoint, however small.

## When to Stop and Ask

**STOP immediately when:**

- A blocker appears — missing dependency, environment problem, failing baseline
- An instruction is genuinely unclear
- The same verification fails twice
- The plan's assumptions about the codebase turn out to be wrong
- Implementing a step would require restructuring code the plan did not anticipate

**Ask rather than guess.** A wrong guess at task 3 corrupts every task after it.

**If verification fails repeatedly:** stop and use systematic-debugging. Do not attempt fix after fix — three failed fixes means the problem is not where you think it is.

## Step 6: Final Verification

Before handing off, **REQUIRED SUB-SKILL:** use verifying-before-completion.

- [ ] Every task in the plan is checked off
- [ ] Full test suite run in this message — output read, 0 failures
- [ ] Linter and build run clean
- [ ] Re-read the plan's goal: does the implementation deliver it?
- [ ] Every deviation reported to the user
- [ ] `git status` clean; every change committed

**Plan coverage check:** walk the plan's requirements and point to the code implementing each. A passing test suite proves the tests pass, not that the plan was fulfilled.

## Step 7: Hand Off

**REQUIRED SUB-SKILL:** Use finishing-a-development-branch to verify tests, present the merge/PR/keep/discard options, and clean up.

## Common Mistakes

**Executing before reviewing.** The plan's flaws get faithfully implemented.

**Skipping "watch it fail".** The plan says run the test and see it fail. Skipping it means you never learn whether the test tests anything.

**Silent deviation.** The implementation drifts from the plan and nobody knows until review.

**Batching all commits at the end.** No revertible checkpoints, and an unreviewable diff.

**Forcing through a blocker.** Three fixes deep on a step that was wrong to begin with.

**"While I'm here" changes.** Unrelated refactoring during execution makes the diff unreviewable and the deviation invisible.

**Claiming completion from memory.** "All tests passed earlier" is not verification. Run them now.

## Integration

**Required workflow skills:**
- **using-git-worktrees** — REQUIRED: isolated workspace before starting
- **writing-plans** — creates the plan this skill executes
- **test-driven-development** — how to execute the test-first steps correctly
- **verifying-before-completion** — REQUIRED before any completion claim
- **finishing-a-development-branch** — REQUIRED: complete development after all tasks

**When things go wrong:**
- **systematic-debugging** — verification failing repeatedly
- **receiving-code-review** — acting on checkpoint review feedback

**Alternative:**
- **subagent-driven-development** — preferred when subagents are available

© osmontero · MIT · osmontero/opencode-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

executing-plans by other authors comes first.

executing-plans Jesse Vincent executing-plans runs an implementation plan in the current session instead of assigning each task to a subagent. Use it for inline work with TDD, a decision ledger, and a final branch review. CX Codex +1 242,988installs executing-plans FradSer executing-plans — a skill for Claude Code, Codex, and Cursor. Executes written implementation plans in task batches using isolated coordinator sub-agents and a single final commit. CX Codex +1 126installs executing-plans mdiri-ai executing-plans is a Claude Code skill that carries out written implementation plans with review checkpoints. It pauses when a blocker needs clarification. CX Codex +1 ★ 6,467repo stars executing-plans dev-toolings The executing-plans skill guides Claude Code through an approved implementation plan, with test-first steps and a separate commit for each one. Use it for multi-step work or to resume after an interruption. CX Codex +1 ★ 234repo stars writing-plans Jesse Vincent writing-plans is a Claude Code and Codex skill that creates a detailed implementation plan for a multi-step task before code changes begin. It runs when the agent has a feature spec or requirements. CX Codex +1 282,859installs azure-test-plans MicrosoftDocs azure-test-plans is a Claude Code skill for configuring Azure Test Plans, including retention limits, custom fields, and access permissions. It also covers failure types and tcm.exe automation. CX Codex +1 171installs create-implementation-plan official github The create-implementation-plan skill creates a Markdown implementation plan for features, refactoring, package upgrades, or infrastructure work. Use it when an agent needs an explicit task breakdown. CX Codex +1 12,558installs update-implementation-plan official github update-implementation-plan updates an existing implementation plan for new requirements, refactoring, package upgrades, or architecture changes. Use it when a plan needs actionable tasks and checks. CX Codex +1 11,107installs paperclip-converting-plans-to-tasks paperclipai The paperclip-converting-plans-to-tasks skill turns an approved plan into owned Paperclip tasks with real dependencies. Use it when work needs deliberate delegation. CX Codex +1 264installs groove-work-plan andreadellacorte groove-work-plan is a Claude Code skill that examines a codebase and drafts an implementation plan. Run it after brainstorming to turn an agreed idea into ordered work. CX Codex +1 546installs

From the same set11

The whole set →
reviewing-interface-quality reviewing-interface-quality audits an existing interface with screenshots, browser data, and CSS values. Use it before shipping or when a page feels unfinished. CX Codex +1 451installs testing-webapps testing-webapps lets an agent test your local web app in a real browser: it writes a Python Playwright script, starts the servers, and reports what the page actually does. CX Codex +1 192installs reviewing-security The reviewing-security skill reviews code before a merge or release by tracing attacker-controlled input to the operation and impact it can reach. CX Codex +1 185installs investigating-performance investigating-performance stops coding agents from guessing at performance bottlenecks by enforcing strict baselines, target metrics, and dimensioned profiling before touching code. CX Codex +1 146installs applying-themes applying-themes puts one palette of eight semantic tokens on a deck, report or HTML page, then verifies the contrast with a bundled script. CX Codex +1 139installs evolving-apis-and-schemas The evolving-apis-and-schemas Claude Code skill assesses changes to APIs and data schemas. It activates when other services, clients, or stored data depend on the shape being changed. CX Codex +1 115installs using-git-worktrees The using-git-worktrees Claude Code skill sets up a separate Git worktree for a task. It kicks in before feature work or an implementation plan when the current checkout should stay untouched. CX Codex +1 103installs creating-skills The creating-skills Claude Code skill helps create and revise other skills, then test how they perform. It activates for requests to draft a skill, evaluate its results, or adjust its trigger description. CX Codex +1 101installs

Project sponsors

Companies that keep this analytics open