Skip to main content

​
Overview

The Executing Plans skill loads a written implementation plan and executes tasks in batches, pausing for review between batches. This creates checkpoints where the architect can provide feedback before continuing.
Core principle: Batch execution with checkpoints for architect review.

​
When to Use

Use when:
  • You have a written implementation plan from Writing Plans
  • You want to execute in a separate session (not the brainstorming session)
  • You want review checkpoints between batches
Alternative: Use Subagent-Driven Development if you want to stay in the current session with per-task subagents.

​
The Process

1

Step 1: Load and Review Plan

  1. Read plan file from docs/plans/YYYY-MM-DD-<feature>.md
  2. Review critically - identify any questions or concerns
  3. If concerns: Raise them with your human partner before starting
  4. If no concerns: Create TodoWrite and proceed
Announce at start:
I'm using the executing-plans skill to implement this plan.
2

Step 2: Execute Batch

Default: First 3 tasksFor each task:
  1. Mark as in_progress in TodoWrite
  2. Follow each step exactly (plan has bite-sized steps)
  3. Run verifications as specified
  4. Mark as completed in TodoWrite
Plans include TDD steps: write test, run to verify fail, implement, run to verify pass, commit.Follow these exactly.
3

Step 3: Report

When batch complete:
Batch 1 complete (Tasks 1-3):

Task 1: Metrics Collector
- Implemented MetricsCollector class
- Tests: 3/3 passing
- Committed: abc123f

Task 2: Storage Layer  
- Implemented SQLite storage
- Tests: 5/5 passing
- Committed: def456a

Task 3: Export to JSON
- Implemented JSON exporter
- Tests: 4/4 passing
- Committed: ghi789b

All tests passing. Ready for feedback.
4

Step 4: Continue

Based on feedback:
  • Apply changes if needed (fix issues, adjust approach)
  • Execute next batch (next 3 tasks)
  • Repeat until complete
5

Step 5: Complete Development

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

​
Visual Workflow

​
Batch Size

Default: 3 tasks per batch Adjust based on:
  • Task complexity (smaller tasks = more per batch)
  • Uncertainty (higher uncertainty = fewer per batch)
  • Human preference (ask if unsure)
"The plan has 12 tasks. I'll execute in batches of 3, 
providing checkpoints after tasks 3, 6, 9, and 12. 
Okay?"

​
When to Stop and Ask

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. Stop and report the blocker.
Example: 
Task 2, Step 3: Blocked

The plan says "Import the validator" but I don't see 
a validator module in the codebase. Should I:
A) Create a new validator module
B) Use an existing validation library
C) Skip validation for now

Waiting for guidance before continuing.

​
When to Revisit Earlier Steps

Return to Review (Step 1) when:
  • Partner updates the plan based on your feedback
  • Fundamental approach needs rethinking
  • Multiple tasks fail in similar ways (plan issue, not implementation issue)
Don’t force through blockers - stop and ask.

​
Example Session

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

[Read docs/plans/2026-03-09-metrics-tracking.md]

Reviewing plan... looks good, no concerns. 
Creating TodoWrite with 12 tasks.

---

Executing Batch 1 (Tasks 1-3):

Task 1: Metrics Collector
[Mark in_progress]
[Follow steps: write test, verify fail, implement, verify pass, commit]
[Mark completed]

Task 2: Storage Layer
[Mark in_progress]  
[Follow steps: write test, verify fail, implement, verify pass, commit]
[Mark completed]

Task 3: Export to JSON
[Mark in_progress]
[Follow steps: write test, verify fail, implement, verify pass, commit]
[Mark completed]

---

Batch 1 complete:

Task 1: Metrics Collector ✓
- Implemented track() and get_events()
- Tests: 3/3 passing
- src/metrics/collector.py:1
- Committed: abc123f

Task 2: Storage Layer ✓
- SQLite persistence
- Tests: 5/5 passing  
- src/metrics/storage.py:1
- Committed: def456a

Task 3: Export to JSON ✓
- JSON exporter with streaming
- Tests: 4/4 passing
- src/metrics/exporters/json.py:1
- Committed: ghi789b

All tests passing (12/12). Ready for feedback.

---

Human: Looks good, continue

You: Executing Batch 2 (Tasks 4-6)...

[Continue until all tasks complete]

---

All tasks complete. Using finishing-a-development-branch skill...

​
Advantages

vs. Manual execution:
  • Systematic progress through plan
  • TodoWrite tracks state
  • Clear checkpoints
vs. Subagent-Driven Development:
  • Simpler (no subagent dispatch)
  • Continuous context (same agent throughout)
  • Good for tightly coupled tasks
Trade-offs:
  • Same agent = context accumulation
  • No fresh perspective per task
  • Better for linear workflows

​
Red Flags

Never:
  • Start implementation on main/master branch without explicit user consent
  • Skip verifications (“I’m sure it works”)
  • Proceed with failing tests (“I’ll fix it later”)
  • Batch more tasks when blocked
  • Guess at unclear instructions
  • Force through blockers
If blocked:
  1. Stop executing
  2. Report the blocker clearly
  3. Wait for guidance
  4. Don’t guess or “try something”

​
Checklist

Before each batch:
  • Marked tasks as in_progress
  • Followed plan steps exactly
  • Ran all verifications
  • All tests passing
  • Committed changes
  • Marked tasks as completed
After each batch:
  • Reported what was implemented
  • Showed verification output
  • Noted any issues or concerns
  • Said “Ready for feedback”
  • Waited for feedback before continuing
Checkpoints create opportunities to correct course before investing too much effort in the wrong direction.

Build docs developers (and LLMs) love

Get started for freeTalk to us