Executing Plans in Batches

Relevant source files

• LICENSE
• commands/brainstorm.md
• commands/execute-plan.md
• commands/write-plan.md
• skills/executing-plans/SKILL.md
• skills/subagent-driven-development/SKILL.md

Purpose and Scope

This document describes the batch execution workflow for implementing plans in a separate session with human review checkpoints between batches of tasks. This approach provides architect oversight at regular intervals while maintaining implementation momentum.

For executing plans with automated subagent review in the same session, see Subagent-Driven Development. For creating the implementation plan that this skill executes, see Writing Implementation Plans. For completing the work after all tasks are done, see Finishing Development Branches.

---

Overview

The executing-plans skill implements a checkpoint-based execution model where the AI agent executes tasks in batches (default: 3 tasks per batch), reports progress, and waits for human feedback before proceeding. This contrasts with the fully automated subagent-driven approach.

Key characteristics:

• Separate session from planning (allows asynchronous work)
• Fixed batch size with human checkpoints
• Single agent context (no subagent dispatching)
• Human review between batches (not automated review loops)
• Explicit stop conditions for blockers

Sources: skills/executing-plans/SKILL.md1-14

---

When to Use This Skill

Choosing Between Execution Modes

Use executing-plans when:

• Architect wants periodic review checkpoints
• Work will happen in parallel/separate session from planning
• Tasks can be executed sequentially by single agent
• Human partner provides direction between batches

Use subagent-driven-development instead when:

• Staying in same session as planning
• Want automated review loops (no human checkpoints)
• Tasks benefit from fresh context per task
• Need faster iteration with automatic quality gates

Sources: skills/executing-plans/SKILL.md1-14 skills/subagent-driven-development/SKILL.md12-36

---

The Five-Step Process

Process Flow

Sources: skills/executing-plans/SKILL.md16-51

---

Step 1: Load and Review Plan

The agent begins by loading the plan file and performing critical review before starting implementation.

Critical Review Checklist

Check	Action if Issue Found
Plan has unclear instructions	Raise concern before starting
Missing dependencies identified	Raise concern before starting
Approach seems flawed	Raise concern before starting
Steps are clear and complete	Create TodoWrite and proceed

Process:

1. Read plan file from docs/plans/YYYY-MM-DD-*.md
2. Review for gaps, ambiguities, or blockers
3. If concerns exist: Stop and raise them (don't guess)
4. If no concerns: Create TodoWrite with all tasks and proceed

Sources: skills/executing-plans/SKILL.md18-23

---

Step 2: Execute Batch

Default Batch Size

The default batch size is 3 tasks. This provides:

• Enough work to show meaningful progress
• Frequent enough checkpoints to catch issues early
• Manageable scope for review and feedback

Per-Task Execution

Execution rules:

• Follow plan steps exactly as written
• Don't skip verification commands
• Don't modify the approach without approval
• Use skills when plan references them
• Stop immediately if blocked (see When to Stop)

Sources: skills/executing-plans/SKILL.md24-32

---

Step 3: Report

When a batch completes, the agent provides a checkpoint report and waits for feedback.

Report Structure

Batch [N] Complete
==================

Implemented:
- Task 1: [description]
  - Files: [list]
  - Changes: [summary]
  
- Task 2: [description]
  - Files: [list]
  - Changes: [summary]

- Task 3: [description]
  - Files: [list]
  - Changes: [summary]

Verification Output:
[paste verification command output]

Ready for feedback.

Critical rule: Just report and wait. Don't:

• Proceed to next batch automatically
• Make assumptions about feedback
• Start changes preemptively

Sources: skills/executing-plans/SKILL.md33-38

---

Step 4: Continue

After receiving feedback, the agent applies any requested changes and either continues or completes.

Continuation Decision Flow

Process:

1. Apply any requested changes to current batch
2. Check if more tasks remain in plan
3. If more tasks: Execute next batch (return to Step 2)
4. If all tasks done: Proceed to Step 5

Sources: skills/executing-plans/SKILL.md39-44

---

Step 5: Complete Development

After all tasks are completed and verified, the agent must use the finishing-a-development-branch skill to properly complete the work.

Completion Requirements

Requirement	Enforced By
All tests passing	finishing-a-development-branch verification
Git worktree cleanup	finishing-a-development-branch workflow
Integration choice (merge/PR/keep/discard)	Human architect decision

Process:

1. Announce: "I'm using the finishing-a-development-branch skill to complete this work."
2. Invoke superpowers:finishing-a-development-branch
3. Follow that skill's workflow exactly

See Finishing Development Branches for complete details.

Sources: skills/executing-plans/SKILL.md45-51

---

When to Stop and Ask for Help

Stop Conditions

The agent must stop executing immediately when any of these conditions occur:

Blocker Examples

Blocker Type	Example	Action
Missing dependency	Plan requires library not installed	Stop, report exact issue
Test failure	Verification command fails	Stop, show failure output
Unclear instruction	Step says "optimize" without specifics	Stop, ask for clarification
Fundamental gap	Plan assumes feature that doesn't exist	Stop, describe gap

Critical rule: Ask for clarification rather than guessing. Don't:

• Try to work around blockers
• Skip failing verifications
• Interpret ambiguous instructions
• Force through with assumptions

Sources: skills/executing-plans/SKILL.md52-61

---

Revisiting Earlier Steps

When to Return to Step 1 (Review)

Triggers for returning to Step 1:

• Architect updates the plan file after feedback
• Discovered issue requires fundamental approach change
• New information invalidates original plan

Don't return to review when:

• Minor clarifications needed (just ask)
• Single task has issue (handle in feedback)
• Verification adjustments needed (apply in current step)

Sources: skills/executing-plans/SKILL.md63-69

---

Integration with Workflow Skills

Required Skills

Integration Points

Workflow Stage	Required Skill	Purpose
Before execution	using-git-worktrees	Create isolated workspace; prevent work on main/master
Plan creation	writing-plans	Generate the implementation plan this skill executes
After execution	finishing-a-development-branch	Verify tests, choose integration option, clean up

Critical rules:

• Never start implementation on main/master branch without explicit user consent
• Always use git worktree for isolated development (see Using Git Worktrees)
• Must invoke finishing-a-development-branch after all tasks (see Finishing Development Branches)

Sources: skills/executing-plans/SKILL.md79-85

---

Code Entity Mapping

Skill File Structure

The executing-plans skill is defined in a single file:

skills/executing-plans/
└── SKILL.md                    # Complete skill definition

Skill Metadata

Process Steps in Code

Section in SKILL.md	Line Range	Maps To
Step 1: Load and Review Plan	18-23	Initial critical review phase
Step 2: Execute Batch	24-32	Per-task execution loop (default 3)
Step 3: Report	33-38	Checkpoint reporting structure
Step 4: Continue	39-44	Feedback processing and iteration
Step 5: Complete Development	45-51	Required sub-skill invocation

Stop Conditions in Code

Sources: skills/executing-plans/SKILL.md1-85

---

Comparison: Batch Execution vs Subagent-Driven

Execution Model Differences

Aspect	Batch Execution (executing-plans)	Subagent-Driven (subagent-driven-development)
Session	Separate from planning	Same session as planning
Agent model	Single agent, sequential tasks	Fresh subagent per task
Review	Human checkpoints between batches	Automated two-stage review per task
Batch size	3 tasks (human review each batch)	1 task (automated review each task)
Speed	Slower (human wait time)	Faster (no human wait)
Context	Accumulates across batch	Fresh per task
Use case	Architect wants periodic oversight	Want automated execution with quality gates

When Each Applies

Sources: skills/executing-plans/SKILL.md1-85 skills/subagent-driven-development/SKILL.md32-37

---

Summary

The executing-plans skill provides checkpoint-based execution for implementation plans, with these characteristics:

Process: 5 steps (Load → Execute → Report → Continue → Complete)

Batch size: Default 3 tasks per checkpoint

Review model: Human review between batches (not automated)

Stop conditions: Immediate stop on blockers, unclear instructions, or verification failures

Required integration:

• Before: using-git-worktrees for isolated workspace
• After: finishing-a-development-branch for completion

Alternative: Use subagent-driven-development for same-session automated execution with per-task review loops.

Sources: skills/executing-plans/SKILL.md1-85