executing-plans

Overview

What the executing-plans skill does

The executing-plans skill is designed for situations where you already have a written implementation plan and you want an agent to carry it out methodically. It focuses on:

• Loading a concrete, step-by-step plan from your project
• Reviewing the plan critically before any work starts
• Executing tasks one by one with clear status changes
• Running verifications and tests as specified in the plan
• Handing off to a finishing workflow once development is complete

At the start of a session, the agent is expected to announce:

"I'm using the executing-plans skill to implement this plan."

This makes it clear that the agent is in structured execution mode, not free-form brainstorming or planning.

Who this skill is for

This skill is a good fit for:

• Developers who prefer to do design upfront, then let an agent execute a detailed plan
• Teams using GitHub and a written implementation plan per feature or branch
• Agent operators working in environments like Claude Code or Codex who want predictable, repeatable execution workflows
• Project maintainers who want consistent adherence to a plan with explicit checkpoints and verification steps

It is especially useful when your plan is already broken down into bite-sized steps and includes clear verification or testing requirements.

What problems executing-plans solves

The executing-plans skill helps you:

• Avoid ad-hoc, drifting implementation by anchoring work to a pre-approved plan
• Catch issues early by requiring a critical review of the plan before any code changes
• Track progress task-by-task, marking work as in_progress and then completed
• Ensure verifications and tests specified in the plan actually get run
• Cleanly hand off to a finishing skill for final test verification and decision-making

By standardizing plan execution, it reduces miscommunication and helps humans and agents collaborate more predictably on development work.

When this skill is and is not a good fit

Use executing-plans when:

• You already have a written implementation plan
• The plan is sequenced into tasks or steps
• You want the agent mainly focused on execution, not designing the solution
• You want checkpoints where the agent asks for help if something is unclear or blocked

Consider a different skill or workflow when:

• You need help creating a plan from scratch (this skill assumes the plan already exists)
• The plan is extremely vague or missing critical details
• Your platform has rich subagent support (e.g., Claude Code, Codex) and you want more advanced orchestration — in that case the repository recommends using superpowers:subagent-driven-development instead
• You are not ready to commit to a particular implementation strategy and still want to explore options

The repository also specifies that, once all tasks are executed, you should transition to the required sub-skill superpowers:finishing-a-development-branch to wrap up the work.

How to Use

Installation and setup

1. Install the executing-plans skill

Install the skill from the obra/superpowers repository:

npx skills add https://github.com/obra/superpowers --skill executing-plans

This makes the executing-plans workflow available in your agent environment.

2. Prepare your implementation plan

Before invoking the skill, ensure you have a written implementation plan in your project. The plan should ideally:

• Be stored in a file your agent can read (for example, in your repo)
• Be broken into individual tasks or bite-sized steps
• Include any required verification or testing instructions for each task

The higher the quality and clarity of this plan, the more reliable the executing-plans workflow will be.

Core workflow: from plan to execution

Step 1: Load and review the plan

When you start a session using executing-plans, the agent should:

1. Read the plan file from your project
2. Review the plan critically, looking for:
   • Missing information or ambiguous instructions
   • Conflicts or contradictions between steps
   • Unrealistic assumptions or prerequisites that may not hold
3. If the agent finds concerns, it should raise them with you before starting any execution
4. If there are no concerns, the agent should create its internal to-do structure (e.g., TodoWrite) and get ready to execute

This review step is crucial. It prevents the agent from blindly following a flawed plan and encourages early clarification.

Step 2: Execute tasks with status tracking

For each task in the plan, the executing-plans skill expects the following pattern:

1. Mark the task as in_progress so you can track live work
2. Follow each step exactly as written in the plan
   • The plan is assumed to have bite-sized, concrete steps
   • The agent should resist improvising unless the plan is clearly insufficient
3. Run verifications as specified
   • This can include running tests, linters, or manual checks described in the plan
4. Mark the task as completed once all work and verifications for that task are done

This structure makes it easier for humans to monitor progress and for the agent to avoid skipping validation.

Step 3: Complete development via finishing skill

Once all tasks in the plan are executed and verified:

• The agent should announce:

  "I'm using the finishing-a-development-branch skill to complete this work."

• Then use the required sub-skill: superpowers:finishing-a-development-branch

• Follow that finishing skill to:

  • Re-run or verify tests as needed
  • Present options or final outcomes (such as branch state or next steps)
  • Execute the chosen finishing actions

Executing-plans is therefore best seen as the middle of your development pipeline: it takes you from a written plan to implemented changes, then hands off to a dedicated finishing workflow.

Handling blockers and uncertainty

When to stop and ask for help

According to the skill definition, the agent must stop executing immediately and ask for help if:

• It hits a blocker, such as:
  • Missing dependencies or tools
  • Tests that fail in unexpected ways
  • Instructions that cannot be carried out with the available context
• The plan has critical gaps that prevent work from starting or continuing
• The agent does not understand part of the plan well enough to proceed confidently

In these cases, the session should switch from execution to clarification, with the agent explaining what is blocking progress and what it needs from you.

Good practices when using executing-plans

To get the most out of the executing-plans skill:

• Write plans that are specific and sequenced, with one clear outcome per task
• Include verification instructions for each major change
• Encourage the agent to summarize concerns it finds during the initial review instead of silently guessing
• Use the finishing-a-development-branch skill consistently after execution so your overall workflow stays predictable

FAQ

What is the executing-plans skill in simple terms?

The executing-plans skill is a structured workflow for agents to load, review, and execute a pre-written implementation plan. It walks through tasks step by step, runs specified verifications, and then passes control to a finishing skill when development is complete.

How do I install the executing-plans skill?

You can install it from the obra/superpowers repository with:

npx skills add https://github.com/obra/superpowers --skill executing-plans

After installation, configure your agent or environment so it can read your implementation plan file and invoke executing-plans for relevant sessions.

Do I need subagents to use executing-plans?

No. The executing-plans skill is designed to work even without subagent support. However, the repository notes that Superpowers works better with subagents, and if your platform supports them (for example, Claude Code or Codex), you should consider using superpowers:subagent-driven-development for richer orchestration instead of executing-plans.

When should I prefer executing-plans over subagent-driven development?

Use executing-plans when:

• Your environment has limited or no subagent support
• You want a straightforward, linear execution of an existing plan
• You value a simple review → execute → finish flow without complex agent orchestration

If you need multi-agent collaboration, dynamic task decomposition, or more autonomous decision-making, the recommended alternative is superpowers:subagent-driven-development.

What kind of plan works best with executing-plans?

Executing-plans works best with plans that are:

• Written down in a file your agent can access
• Broken into bite-sized, ordered tasks
• Clear about expectations, inputs, and outputs
• Explicit about verification or testing steps after each change

High-level or vague plans are likely to trigger more clarification cycles and block execution.

How does executing-plans handle tests and verifications?

The skill expects the plan to describe which tests or verifications to run. For each task, the agent should:

• Carry out the code or configuration changes described
• Run the specific tests, checks, or commands mentioned in the plan
• Only mark the task as completed once those verifications succeed or are reconciled with you

This makes test execution part of the workflow, not an afterthought.

What happens after all tasks are done?

Once all tasks are executed and their verifications are successful, executing-plans hands off to the finishing-a-development-branch workflow:

• The agent announces it is switching to the finishing skill
• It uses superpowers:finishing-a-development-branch as a required sub-skill
• That skill is responsible for final checks, presenting options, and executing your chosen finishing actions

This separation keeps execution and finalization concerns clean and easier to reason about.

What if the plan turns out to be wrong?

If the agent discovers that following the plan would cause incorrect behavior or cannot succeed as written, it should:

1. Stop executing further tasks
2. Explain clearly what is wrong with the plan
3. Ask you whether to update the plan, create a new one, or switch to a different workflow

Executing-plans assumes the plan is the source of truth; when that assumption fails, human review is required.

Is executing-plans only for code changes?

The skill is primarily oriented toward development work (code and related tasks), but the same pattern—load plan, review, execute tasks, run verifications—can apply to other project workflows that are well-specified. For best results, use it where you can define clear tasks and objective checks for success.

How can I evaluate if executing-plans is working well for my project?

Look for these signs:

• Tasks from your plan are consistently marked in_progress and completed with clear traceability
• The agent regularly runs the verifications you specify and reports their outcomes
• You receive early notifications when the plan is unclear or blocked
• The handoff to finishing-a-development-branch feels smooth and predictable

If those conditions hold, executing-plans is likely a good match for your team’s project-management and workflow-automation needs.