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 (Enhanced with BD Features)

Step 1: Load and Review Plan

1. Read plan file
2. Search for similar work: bd search "$PLAN_KEYWORDS"
3. Review critically - identify any questions or concerns about the plan
4. If concerns: Raise them with your human partner before starting
5. If no concerns: Create epic with all tasks and proceed

Step 2: Create Epic and Tasks

# Create epic for the entire plan
bd create "$PLAN_TITLE" --type epic --estimate $TOTAL_MINUTES
EPIC_ID=<created-id>

# Pin it for session visibility
bd pin $EPIC_ID

# Extract tasks and create with estimates
bd create "Task 1" --parent $EPIC_ID --estimate 30 --labels "batch-1,implementation"
bd create "Task 2" --parent $EPIC_ID --estimate 25 --labels "batch-1,implementation" --deps blocks:<task1>
bd create "Task 3" --parent $EPIC_ID --estimate 40 --labels "batch-2,implementation"
# ... continue for all tasks

Step 3: Execute Batch

Default: First 3 ready tasks

# Check for stale work from previous sessions
bd stale --days 1
bd list --status in_progress

# Get ready tasks (respects dependencies)
bd ready

# Start batch execution
bd update <id1> <id2> <id3> --status in_progress

For each task: 1. Follow each step exactly (plan has bite-sized steps) 2. Run verifications as specified 3. Add audit trail: bd audit "Task X: <key decisions/findings>" 4. Update labels: bd update <id> --add-label "tested" 5. Mark as completed: bd close <id>

Step 4: Report

When batch complete:

# Show completed work with time spent
bd list --status closed --parent $EPIC_ID --created-after today

# Check epic progress
bd show $EPIC_ID

# Show remaining work with estimates
bd ready

• Show what was implemented
• Show verification output
• Report time spent vs estimates
• Say: "Ready for feedback."

Step 5: Continue

Based on feedback: - Apply changes if needed - Check next batch: bd ready (automatically respects dependencies) - Update estimates if needed: bd update <id> --estimate 60 - Repeat until complete

Step 6: Complete Development

After all tasks complete and verified:

# Check for any forgotten work
bd stale --days 0
bd list --status open --parent $EPIC_ID
# Should return: "No open issues"

# Unpin the epic
bd unpin $EPIC_ID

# Close the epic
bd close $EPIC_ID

• 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

BD-Enhanced Workflow

Creating Tasks with Dependencies and Estimates

# Always search first
bd search "$KEYWORDS_FROM_PLAN"

# Create epic with total estimate
bd create "Plan: $TITLE" --type epic --estimate 240  # 4 hours total
bd pin $EPIC_ID  # Keep visible

# Extract tasks with realistic estimates
# Guidelines:
# - Simple task: 15-30 min
# - Medium complexity: 30-60 min
# - Complex with tests: 60-90 min

bd create "Setup database" --parent $EPIC_ID --type task --priority 1 \
  --estimate 30 --labels "infrastructure,batch-1"

bd create "Create API" --parent $EPIC_ID --type task --priority 2 \
  --estimate 60 --labels "backend,batch-1" \
  --deps blocks:setup-db

bd create "Build UI" --parent $EPIC_ID --type task --priority 2 \
  --estimate 45 --labels "frontend,batch-2" \
  --deps blocks:setup-db

bd create "Integration tests" --parent $EPIC_ID --type task --priority 3 \
  --estimate 30 --labels "testing,batch-3" \
  --deps blocks:create-api,blocks:build-ui

# Visualize the plan
bd graph --epic $EPIC_ID

Tracking Progress with Labels

# Semantic labels for filtering
--labels "batch-1,backend"      # Batch assignment
--labels "tested,reviewed"       # Status tracking
--labels "blocked,needs-input"  # Issues

# Filter by batch
bd list --label batch-1 --parent $EPIC_ID
bd list --label batch-2 --parent $EPIC_ID

# Find what needs attention
bd list --label needs-input
bd list --label blocked

Handling Blockers and Context

# Mark task as blocked with reason
bd update <id> --status blocked
bd comment <id> "Blocked: Missing API credentials from client"
bd audit "Blocker: Awaiting client credentials for payment gateway"

# When unblocked
bd update <id> --status open
bd comment <id> "Unblocked: Received credentials"

Session Recovery After Interruption

# After interruption, quick recovery:
bd list --status in_progress     # What was being worked on
bd stale --hours 4               # Recent but stale work
bd list --parent $PINNED_EPIC    # All tasks in current plan
bd show $PINNED_EPIC             # Overall progress and estimates
bd graph --epic $PINNED_EPIC     # Visual state of dependencies

# Resume from exact point
bd ready  # Shows next unblocked tasks

When to Stop and Ask for Help

STOP executing immediately when: - Hit a blocker mid-batch (missing dependency, test fails, instruction unclear) - Mark as blocked: bd update <id> --status blocked - Add audit: bd audit "Blocked: <detailed reason>" - Plan has critical gaps preventing starting - You don't understand an instruction - Verification fails repeatedly - Estimates way off (task taking 3x longer than estimated)

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 - Dependencies need restructuring: bd dep remove <id> blocks <other>

Don't force through blockers - stop and ask.

Advantages of BD Integration

Persistence: - Plan survives session restarts - Can resume work exactly where left off - Full history of attempts and decisions

Visibility: - Partner can run bd status to see progress - bd show $EPIC_ID shows time spent vs estimates - bd sync pushes updates to git for team visibility - Audit trail provides decision history

Dependencies: - Automatic task ordering based on blocks/blocked-by - Can't accidentally work on blocked tasks - Clear view of what unblocks what

Time Management: - Estimates help set expectations - Can report accurate progress percentages - Identify which tasks consistently run over

Flexibility: - Can defer tasks: bd defer <id> --comment "Descoped for MVP" - Can reprioritize: bd update <id> --priority 0 - Can add new tasks mid-execution

Red Flags

Never: - Skip search before creating tasks - Create tasks without estimates - Forget to pin the epic for visibility - Execute blocked tasks - Skip audit trail for decisions - Ignore stale task warnings - Close epic with open child tasks

Always: - Search for similar work first - Create epic for multi-task plans - Add realistic time estimates - Use semantic labels for organization - Check stale tasks when resuming - Audit important decisions - Unpin and close epic when done

Remember

• Review plan critically first
• Search for similar work before starting
• Create epic and pin it
• Add estimates to set expectations
• Create all tasks with proper dependencies
• Follow plan steps exactly
• Don't skip verifications
• Reference skills when plan says to
• Between batches: report progress with time data
• Stop when blocked, don't guess
• Keep bd updated for session continuity
• Unpin and close epic when complete