executing-plans

Trevoke's avatarfrom Trevoke

Use when you have a written implementation plan to execute in a separate session with review checkpoints

⭐429stars🔀52forks📁View on GitHub🕐Updated Jan 3, 2026⬇️1downloads

When & Why to Use This Skill

The Executing Plans skill is a specialized workflow designed for structured, multi-step implementation of complex projects. It enables Claude to transform written plans into actionable tasks, manage them through epics and dependencies, and execute them in controlled batches with mandatory review checkpoints. This skill is optimized for maintaining session persistence, tracking time estimates, and ensuring high-quality output through rigorous verification and audit trails.

Use Cases

  • Complex Software Implementation: Breaking down a high-level technical architecture into granular, estimated tasks with clear dependency mapping to ensure orderly development.
  • Multi-Session Task Continuity: Resuming long-running projects across different AI sessions by utilizing persistent task tracking, status updates, and session recovery tools.
  • Structured Progress Reporting: Providing stakeholders with detailed audit trails, time-spent analysis, and visual progress graphs (via epics) to maintain transparency during execution.
  • Quality-Controlled Batch Execution: Implementing features in logical groups (batches) and stopping for human review between each phase to prevent error propagation.
nameexecuting-plans
descriptionUse when you have a written implementation plan to execute in a separate session with review checkpoints

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