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

The Process

Step 1: Load and Review Plan

Load from beads:

# 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:

1. Read epic description and task list from beads
2. Review markdown reference file if available: docs/plans/YYYY-MM-DD-<topic>.md
3. Review critically - identify any questions or concerns about the plan
4. Check task dependencies with bd show <task-id>
5. If concerns: Raise them with your human partner before starting
6. 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:

# 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:

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

2. Get task details:

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:

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:

  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:

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

Step 5: Complete Development

After all tasks complete and verified:

• Check all tasks closed:

  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:

  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:

1. User provides epic ID (e.g., superpowers-abc123)
2. Load epic and task list from beads
3. Execute ready tasks in batches (no blockers)
4. Update task status as you work (in_progress → closed)
5. Beads automatically unblocks dependent tasks
6. Continue until all tasks complete
7. 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:

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