Source: obra/superpowers · Maintainer: community: Jesse Vincent (Prime Radiant) · License: MIT · Checked: 24 October 2026
What is the executing plans skill?
The executing plans skill has a coding agent carry out a written implementation plan itself, one task at a time in the current session, proving each step with a test it watched fail and then pass. Instead of a reviewer after every task, it pays for one fresh review of the whole branch at the end.
It is one of the two execution skills in Superpowers, the open source library by Jesse Vincent and Prime Radiant, and it runs plans made by the writing plans skill. The skill's description begins: "Use when executing an implementation plan in the current session as the implementer yourself". It goes on to name the two cases: you chose inline execution, or no subagent tool is available.
Its skills.sh page listed about 243,000 installs (snapshot, 24 October 2026), and all three security audits shown there (Gen Agent Trust Hub, Socket and Snyk) were Pass.
What does it do?
The SKILL.md states its core principle plainly: "The plan already did the thinking." The agent executes it exactly, proves every step, and leaves a record that survives its own forgetting.
Setup. The agent works in an isolated workspace, using superpowers:using-git-worktrees, and never starts on main or master without your explicit consent. It creates a git-ignored folder for the plan at .superpowers/sdd/<plan-basename>/ with a ledger file, progress.md. It reads the plan and the spec it names, then scans the tasks' Interfaces blocks for conflicts before Task 1. It also loads superpowers:test-driven-development, which governs every step.
The task loop. For each task:
scripts/task-startextracts the task's brief to a file and records the starting commit. The agent reads the brief every time, because "You remember a summary. The brief has the exact values."- It works the steps in red-green order. Each command has an
Expected:line. If the output differs because the code is wrong, it switches tosuperpowers:systematic-debugging. If the plan is wrong, it rules on the smallest fix that satisfies the spec and writes aRuling:line to the ledger. - It commits as the plan says.
scripts/task-doneruns the task's tests, saves the output, and appends a completion line to the ledger only if they pass.
Continuous execution. The agent does not ask "should I continue?" between tasks. Only four things stop it: an irreversible or destructive operation, a security-sensitive action, a side effect outside the worktree such as a merge or a push to a shared branch, and a plan so broken that every path forward is a guess.
Final review. After the last task, it builds a review package of the branch diff and, if a subagent tool exists, dispatches one fresh reviewer on the most capable model available. Critical and Important findings get one fix pass, each fix proven with a failing test first. Minor findings are logged as deferred, not fixed. Without a subagent tool, the agent reviews its own branch and says so in the ledger and its final message.
Finish. Its final message lists every ruling it made, with what each costs if wrong, plus every deferred minor. Then it deletes the plan's workspace and hands off to superpowers:finishing-a-development-branch.
What's in the folder:
SKILL.md: the process, the completion contract and a rationalizations table.scripts/task-start: a bash script that writes a task's brief and prints the base commit.scripts/task-done: a bash script that runs your test command and updates the ledger on success.
How do you install the executing plans skill?
As part of Superpowers in Claude Code. The Superpowers README installs it from Anthropic's official marketplace:
/plugin install superpowers@claude-plugins-official
Plugin skills are namespaced as /plugin-name:skill-name per the Claude Code skills docs, so it shows up as /superpowers:executing-plans. The README also documents the obra/superpowers-marketplace route and installs for Codex, Cursor, Gemini CLI and other agents.
Just this skill. The skills CLI can copy one folder, exactly as shown on the skills.sh page:
npx skills add https://github.com/obra/superpowers --skill executing-plans
Add -g to install for all projects and -a claude-code to target Claude Code. The folder lands in .claude/skills/executing-plans/ in your project, or ~/.claude/skills/executing-plans/ with -g. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.
One catch with a standalone copy: task-start calls task-brief and task-done calls sdd-workspace from the sibling subagent-driven-development/scripts/ folder, and the setup and final review run sdd-workspace and review-package from there too. Install the subagent driven development skill next to it, or install the whole plugin. The skill also leans on test-driven-development, systematic-debugging, verification-before-completion, using-git-worktrees, requesting-code-review and finishing-a-development-branch.
Because it depends on git, bash scripts and sibling skills, it fits a coding agent rather than a ZIP upload to the Claude apps.
How do you use it?
You need a plan first, ideally one from writing-plans. When that skill finishes, it asks how to execute; choosing "Native" routes here. You can also invoke it directly.
Example prompts (suggestions, not quotes from the repo):
Run docs/superpowers/plans/2026-10-22-csv-export.md inline. No subagents./superpowers:executing-plans docs/superpowers/plans/2026-10-24-rate-limits.mdResume the plan from the ledger. Tasks 1 to 4 are already committed.Execute the webhooks plan on a new worktree and stop before you merge anything.
Requirements: a git repo, bash, and your project's test command, which task-done runs at the end of every task.
The SKILL.md notes that a fully specified plan "runs well on a mid-tier session model," and that the most capable model earns its cost in the final review, which the skill dispatches separately.
When should you pick it over subagent-driven development?
The two skills share the same workspace and ledger format, so a plan can switch executors partway and resume. The difference is where review happens.
| executing-plans | subagent-driven-development | |
|---|---|---|
| Who implements | The agent in your session | A fresh subagent per task |
| Review | One whole-branch review at the end | A review after every task, plus a final one |
| Cost | One context plus one reviewer, per the skill | A fresh context per task and per review |
| Per-task gate | TDD and the completion contract | A reviewer checking spec and quality |
| Best when | You chose inline, or there is no subagent tool | You want a gate on every task, or the plan is long |
The skill warns that on a long plan, "the last tasks get the least of you," because they may run on a compacted context.
Tips and limits
From the files, not from testing:
- Read the rulings list. It is the only place the decisions the agent made for you reach you. Rework any you disagree with.
- No check-ins means fewer chances to steer. If you want to approve each task, use a different approach or tell the agent so up front.
- Self-review is weaker. Without a subagent tool, the author reviews its own branch, and the skill says you decide whether that is enough before merging.
- Don't run
git clean -fdxmid-plan. The workspace is git-ignored and would be deleted; the skill says to recover fromgit logif that happens. - What runs.
task-start,task-doneand the sibling helper scripts, plus your own test command. Read them first, like any script. - License. MIT, so you can copy and edit the skill if you keep the copyright notice.
Save it in your Kipt library
In Kipt, open Skills and paste the skill's GitHub folder link into the import box. Kipt reads the SKILL.md and its scripts; for a repo with many skills it shows a list to pick from, so you can take subagent-driven-development in the same import and keep the shared scripts working. You can also drop the folder or a .zip. Your skills live in your own private GitHub repo and install into Claude Code or Codex with one command:
npx skills add https://github.com/<you>/<repo>.git --all -g
Kipt is not affiliated with Jesse Vincent, Prime Radiant or Superpowers.
Similar skills
- Superpowers skills: the full workflow around this execution step.
- Systematic debugging skill: what the agent switches to when a step's output is wrong.
- TDD skill: Matt Pocock's red-green loop, an alternative take on test-first steps.
- Code review skill: a two-axis review you can run on the finished branch.