playbooks

home / skills / oimiragieo / agent-studio / executing-plans

executing-plans skill

/.claude/skills/_archive/dead/executing-plans

This skill executes plans in structured batches with checkpoints, enabling critical review, verifications, and iterative feedback for reliable delivery.

npx playbooks add skill oimiragieo/agent-studio --skill executing-plans

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

Files (1)
SKILL.md
2.7 KB
---
name: executing-plans
description: Execute plans in batches with review checkpoints. Use when implementing a plan file.
version: 1.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit, Bash, Task]
best_practices:
  - Execute in batches of 3 tasks
  - Report between batches
  - Stop if blocked
  - Revisit plan on significant changes
error_handling: graceful
streaming: supported
---

# 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 verification-before-completion skill to complete this work."
- **REQUIRED SUB-SKILL:** Use verification-before-completion
- 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

## Memory Protocol (MANDATORY)

**Before starting:**
Read `.claude/context/memory/learnings.md`

**After completing:**

- New pattern -> `.claude/context/memory/learnings.md`
- Issue found -> `.claude/context/memory/issues.md`
- Decision made -> `.claude/context/memory/decisions.md`

> ASSUME INTERRUPTION: If it's not in memory, it didn't happen.

Overview

This skill runs implementation plans in controlled batches with review checkpoints to ensure correctness and alignment. It prioritizes a critical pre-run review, batch execution of tasks with step-by-step verification, and reporting between batches to gather feedback. The process enforces stop conditions and memory updates to preserve project continuity.

How this skill works

Before executing, load and critically review the plan file and raise any concerns. Execute tasks in small batches (default: first three tasks), marking progress, running specified verifications, and reporting results. After each batch, present what was implemented and verification output, wait for feedback, then continue or apply requested changes until all tasks are complete. On completion, invoke the verification-before-completion sub-skill to finalize tests and present final options.

When to use it

  • Implementing a written plan file that contains bite-sized tasks and verifications
  • Work that benefits from iterative review and frequent checkpoints
  • Projects where tests or verifications must run after each set of changes
  • Situations where human review is required before proceeding
  • When interruptions or handoffs are expected and memory must be recorded

Best practices

  • Start every run by announcing you will use the executing-plans skill and perform a critical review of the plan
  • Execute small batches (default three tasks) and follow each step exactly as written
  • Run all specified verifications and include verification output in the batch report
  • Stop immediately and ask for clarification on blockers, unclear instructions, or repeated verification failures
  • Record learnings, issues, and decisions to the mandated memory files after completion
  • Invoke the verification-before-completion sub-skill to finalize work and confirm readiness

Example use cases

  • Implementing a feature described in a plan file with step-by-step tasks and tests
  • Refactoring code in increments while running unit tests after each batch
  • Onboarding a new team member to execute documented tasks under supervision
  • Handling complex deployments where checkpoints and human approval are required
  • Iterative bug fixes that require verification and reviewer sign-off between batches

FAQ

What do I announce at the start?

Announce that you are using the executing-plans skill to implement the plan and then perform a critical review before executing any tasks.

When should I stop executing mid-batch?

Stop immediately if you encounter a blocker, missing dependency, unclear instruction, or repeated verification failure, and ask for clarification rather than guessing.