home / skills / jackspace / claudeskillz / executing-plans_obra

executing-plans_obra skill

This skill loads an implementation plan, reviews it critically, executes tasks in batches, and reports results for review and refinement.

This is most likely a fork of the executing-plans skill from mosif16

npx playbooks add skill jackspace/claudeskillz --skill executing-plans_obra

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

Files (3)

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 implementation plan in controlled batches with review checkpoints. It loads and reviews the plan critically, executes small groups of tasks exactly as specified, and reports verification results between batches. At the start it announces: "I'm using the executing-plans skill to implement this plan."

How this skill works

The skill reads the supplied plan, lists questions or concerns, and stalls for clarification if anything is unclear. If the plan is acceptable it creates a todo list and executes the first batch (default: three tasks), marking tasks in_progress, running specified verifications, and marking them completed. After each batch it reports what was implemented and the verification output, then waits for feedback before continuing. On full completion it hands off to the finishing-a-development-branch sub-skill to run final tests and finalize the branch.

When to use it

You have a detailed, stepwise execution plan and want controlled, reviewable progress.
Work must be executed in repeatable batches with verification between batches.
You need an agent to follow exact steps and never skip specified verifications.
There are stakeholders who must review and approve progress regularly.
You want clear stop rules so the agent asks for clarification on blockers.

Best practices

Provide a complete, bite-sized step plan with explicit verification steps.
Expect the agent to pause and ask if any instruction is unclear or a dependency is missing.
Keep batch sizes small (default three tasks) so reviews remain manageable.
Specify required sub-skills explicitly in the plan (e.g., finishing-a-development-branch).
Treat reports between batches as the primary checkpoint for feedback and changes.

Example use cases

Implementing a feature from a precise implementation plan across multiple commits.
Running bioinformatics pipeline stages where outputs must be validated before proceeding.
Deploying infrastructure changes in controlled batches with rollbacks gated by verification.
Executing a data-science experiment plan that requires intermediate result checks and sign-off.
Applying a long development task that must be reviewed incrementally by an architect.

FAQ

What happens if a verification step fails?

Stop execution immediately, report the failure and the output, and request clarification or a plan change before continuing.

Can batch size be changed?

Yes. Default is three tasks, but the partner can set a different batch size in the plan before execution starts.

Does the skill make changes if the plan is ambiguous?

No. The skill raises questions and waits for clarifications rather than guessing.