home / skills / mosif16 / codex-skills / executing-plans

executing-plans skill

safe

This skill loads a plan, reviews it critically, executes tasks in batches, and reports results for review between batches.

npx playbooks add skill mosif16/codex-skills --skill executing-plans

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.2 KB

---
name: executing-plans
description: Use when partner provides a complete implementation plan to execute in controlled batches with review checkpoints - loads plan, reviews critically, executes tasks in batches, reports for review between batches
---

# Executing Plans

## Overview

Load plan, review critically, execute tasks in batches, report for review between batches.

**Core principle:** Batch execution with checkpoints for architect review.

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

## The Process

### Step 1: Load and Review Plan
1. Read plan file
2. Review critically - identify any questions or concerns about the plan
3. If concerns: Raise them with your human partner before starting
4. If no concerns: Create TodoWrite and proceed

### Step 2: Execute Batch
**Default: First 3 tasks**

For each task:
1. Mark as in_progress
2. Follow each step exactly (plan has bite-sized steps)
3. Run verifications as specified
4. Mark as completed

### Step 3: Report
When batch complete:
- Show what was implemented
- Show verification output
- Say: "Ready for feedback."

### Step 4: Continue
Based on feedback:
- Apply changes if needed
- Execute next batch
- Repeat until complete

### Step 5: Complete Development

After all tasks complete and verified:
- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
- Follow that skill to verify tests, present options, execute choice

## When to Stop and Ask for Help

**STOP executing immediately when:**
- Hit a blocker mid-batch (missing dependency, test fails, instruction unclear)
- Plan has critical gaps preventing starting
- You don't understand an instruction
- Verification fails repeatedly

**Ask for clarification rather than guessing.**

## When to Revisit Earlier Steps

**Return to Review (Step 1) when:**
- Partner updates the plan based on your feedback
- Fundamental approach needs rethinking

**Don't force through blockers** - stop and ask.

## Remember
- Review plan critically first
- Follow plan steps exactly
- Don't skip verifications
- Reference skills when plan says to
- Between batches: just report and wait
- Stop when blocked, don't guess

Overview

This skill implements a partner-provided plan by loading it, reviewing it critically, and executing tasks in controlled batches with review checkpoints. The core principle is batch execution with explicit verification and feedback pauses to avoid guessing and reduce risk. It includes clear stop rules and a required finishing sub-skill for finalization.

How this skill works

First, the skill loads the plan file and performs a critical review, raising any questions before execution. It then executes a default initial batch (first three tasks) by marking tasks in_progress, following the plan steps exactly, running specified verifications, and marking tasks completed. After each batch it reports results and verification output, waits for feedback, applies requested changes, and repeats until the plan is complete. On finalization it invokes the finishing-a-development-branch sub-skill to run final checks and present options.

When to use it

A partner provides a complete, step-by-step implementation plan and wants controlled execution.
You need to run work in small batches with verification and human review between batches.
Risk of incorrect assumptions is high and explicit feedback checkpoints are required.
When plan steps include built-in verifications that must not be skipped.
When the workflow requires a formal handoff to a finishing procedure at the end.

Best practices

Always perform a critical review of the plan and raise clarifying questions before starting.
Execute small batches (default first three tasks) and never skip specified verifications.
Mark task states (in_progress, completed) clearly and report verification output after each batch.
Stop immediately and ask for clarification on blockers, unclear instructions, or failing verifications.
Use the finishing-a-development-branch sub-skill at completion to verify tests and finalize changes.

Example use cases

Implementing a multi-step feature where each step has unit tests or smoke checks attached.
Applying infrastructure changes in stages with human approval between batches.
Executing a migration plan that must be validated incrementally to avoid data loss.
Running an onboarding checklist for a new module that requires sign-off after each subset of tasks.

FAQ

What if I find gaps in the plan during review?

Stop and raise the gaps with the partner. Do not start execution until clarifying answers are provided.

How large should a batch be?

Default is the first three tasks; adjust only with partner agreement to keep batches small and reviewable.

When do I invoke the finishing sub-skill?

After all tasks are completed and verified, invoke the finishing-a-development-branch sub-skill to run final checks and present completion options.