Executing Plans

Overview

Load plan from beads, 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."

Storage: Plans are tracked in beads epics with markdown reference files for documentation.

The Process

Step 1: Load and Review Plan

Load from beads:

bash

# Source helper functions
source skills/lib/beads-helper.sh

# Get the epic ID (from user or markdown file)
EPIC_ID="superpowers-abc123"

# View epic details
bd show "$EPIC_ID"

# List ready tasks (no blockers)
bd ready --parent "$EPIC_ID"

# List all tasks
bd list --parent "$EPIC_ID" --status open

Review process:

•Read epic description and task list from beads
•Review markdown reference file if available: docs/plans/YYYY-MM-DD-<topic>.md
•Review critically - identify any questions or concerns about the plan
•Check task dependencies with bd show <task-id>
•If concerns: Raise them with your human partner before starting
•If no concerns: Proceed with execution

No TodoWrite needed - beads tracks all state persistently.

Step 2: Execute Batch

Default: First 3 ready tasks

Get ready tasks:

bash

# Get tasks with no blockers
bd ready --parent "$EPIC_ID" --format json | jq -r '.[0:3][] | .id'

For each task:

1. Mark as in_progress:

bash

TASK_ID="superpowers-abc123.1"
bd update "$TASK_ID" --status in_progress

2. Get task details:

bash

bd show "$TASK_ID"
# Review the description field for all steps

3. Follow each step exactly:

•Plan has bite-sized steps in task description
•Execute them one by one
•Run verifications as specified

4. Mark as completed:

bash

bd close "$TASK_ID"
# This automatically updates status to 'closed'
# Unblocks any dependent tasks

Between tasks: Let beads track the state. No manual status tracking needed.

Step 3: Report

When batch complete:

•Show what was implemented (list completed task IDs)
•Show verification output

•Check remaining work:

bash

bd ready --parent "$EPIC_ID"
bd list --parent "$EPIC_ID" --status open

•Say: "Ready for feedback."

Step 4: Continue

Based on feedback:

•Apply changes if needed
•Update task status if reopening: bd update <task-id> --status open
•Get next batch of ready tasks: bd ready --parent "$EPIC_ID"
•Execute next batch
•Repeat until complete

Check progress:

bash

bd show "$EPIC_ID"  # Shows all children with status

Step 5: Complete Development

After all tasks complete and verified:

•Check all tasks closed:

bash

bd list --parent "$EPIC_ID" --status open  # Should be empty
bd show "$EPIC_ID"  # All children should show closed

•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

•After merging/pushing, close the epic:

bash

bd close "$EPIC_ID"
bd sync  # Sync beads to git

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.

Beads Integration

This skill reads implementation plans from beads epics and updates task status during execution.

Workflow:

•User provides epic ID (e.g., superpowers-abc123)
•Load epic and task list from beads
•Execute ready tasks in batches (no blockers)
•Update task status as you work (in_progress → closed)
•Beads automatically unblocks dependent tasks
•Continue until all tasks complete
•Close epic and sync to git

Key Commands:

•Get epic: bd show <epic-id>
•List ready tasks: bd ready --parent <epic-id>
•List all tasks: bd list --parent <epic-id> --status <status>
•Get task details: bd show <task-id>
•Start task: bd update <task-id> --status in_progress
•Complete task: bd close <task-id>
•Close epic: bd close <epic-id>
•Sync to git: bd sync

Task Status Flow:

code

open → in_progress → closed
      ↑ (if reopening)

Dependencies:

•Beads tracks dependencies automatically
•bd ready only shows tasks with no blockers
•Closing a task unblocks its dependents
•Check dependencies: bd show <task-id> (shows "depends on" section)

No TodoWrite:

•Beads replaces TodoWrite entirely
•All state persists in .beads/ directory
•Synced to git via bd sync
•Survives session restarts

Remember

•Get epic ID from user or markdown reference file
•Review plan critically first with bd show <epic-id>
•Use bd ready to find unblocked tasks
•Update beads status as you work (in_progress/closed)
•Follow plan steps exactly from task descriptions
•Don't skip verifications
•Reference skills when plan says to
•Between batches: report, sync beads, wait
•Stop when blocked, don't guess
•Close epic and sync when fully complete
•Never start implementation on main/master branch without explicit user consent

Integration

Required workflow skills:

•superpowers:using-git-worktrees - REQUIRED: Set up isolated workspace before starting
•superpowers:writing-plans - Creates the plan this skill executes
•superpowers:finishing-a-development-branch - Complete development after all tasks