Autopilot: Sequential Phase Implementation

Run all phases of a feature sequentially via subagents, respecting dependencies.

User Input

ARGUMENTS = $ARGUMENTS

Accept a feature number (e.g., "003") or use current branch if not provided.

/autopilot 003        # Run all phases for feature 003
/autopilot            # Run all phases for current branch's feature

Execution Flow

/autopilot 003
       │
       ▼
┌─────────────────────┐
│  Load Feature       │
│  • Find tasks.md    │
│  • Parse phases     │
│  • Build order      │
└─────────┬───────────┘
       │
       ▼
┌─────────────────────┐
│  For Each Phase:    │
│                     │
│  ┌───────────────┐  │
│  │ Spawn Agent   │  │
│  │ /implement    │  │
│  │ "Phase N"     │  │
│  └───────┬───────┘  │
│          │          │
│          ▼          │
│  ┌───────────────┐  │
│  │ Wait for      │  │
│  │ Completion    │  │
│  └───────┬───────┘  │
│          │          │
│          ▼          │
│  ┌───────────────┐  │
│  │ Report Status │  │
│  │ → Next Phase  │  │
│  └───────────────┘  │
└─────────────────────┘
       │
       ▼
┌─────────────────────┐
│  Final Summary      │
└─────────────────────┘

Workflow

Step 1: Resolve Feature

1. If ARGUMENTS provided, use as feature number (e.g., "003")
2. If no ARGUMENTS, extract from current git branch:

   git branch --show-current
   # feature/003-agent-behavior-statecharts → 003
   

3. Find feature folder in backlog/plans/{NNN}-*/

Step 2: Parse Phases from tasks.md

Read {feature-path}/tasks.md and extract phases:

## Phase 1: Core Types
## Phase 2: Statechart Engine
## Phase 3: LLM Reasoner
...

Build ordered list: ["Phase 1", "Phase 2", "Phase 3", ...]

Step 3: Sequential Execution

For each phase in order:

1. Spawn subagent using Task tool:

   Task(
     subagent_type: "general-purpose",
     description: "Implement Phase N",
     prompt: """
   Implement Phase N for feature {feature-id}.
   
   CRITICAL: Your first action must be to invoke the implement skill:
   
   Skill(skill: "implement", args: "Phase N")
   
   The implement skill will guide you through TDD workflow for all tasks in this phase.
   Do NOT try to implement tasks manually - invoke the Skill tool first.
   
   Report success or failure when the phase is complete.
   """,
     run_in_background: false  # Wait for completion
   )
   

2. Wait for completion before starting next phase

3. Check result - if phase fails, stop and report

Step 4: Progress Reporting

After each phase completes, report:

✅ Phase 1: Complete (T001-T006)
🔄 Phase 2: In Progress...

Step 5: Final Summary

After all phases complete:

🎉 Autopilot Complete: Feature 003

✅ Phase 1: Core Types (T001-T006)
✅ Phase 2: Statechart Engine (T007-T015)
✅ Phase 3: LLM Reasoner (T016-T023)
✅ Phase 4: Timeout Transitions (T024-T029)
✅ Phase 5: Agent Integration (T030-T039)
✅ Phase 6: Queries + Validation (T040-T047)

All 47 tasks completed.

Next steps:
1. Run linting: uv run ruff check . && uv run flake8 .
2. Run tests: uv run pytest
3. Run spec tests: /spec-tests specs/tests/003-*.md
4. Create PR when ready

Error Handling

If a phase fails:

1. Stop execution - don't proceed to dependent phases
2. Report failure with context:

   ❌ Phase 3 failed
   
   Completed: Phase 1, Phase 2
   Failed: Phase 3 (LLM Reasoner)
   Skipped: Phase 4, Phase 5, Phase 6
   
   Error: [error details from agent]
   
   To resume: /implement "Phase 3"
   

3. Preserve progress - completed phases remain done

Running in Background

For long-running features, run autopilot in background:

# In the skill execution, use:
Task(
  ...
  run_in_background: true
)

Then check progress with:

tail -100 {output_file}

Example Session

User: /autopilot 003

Claude: Starting autopilot for feature 003-agent-behavior-statecharts

Found 6 phases to implement:
1. Phase 1: Core Types (T001-T006)
2. Phase 2: Statechart Engine (T007-T015)
3. Phase 3: LLM Reasoner (T016-T023)
4. Phase 4: Timeout Transitions (T024-T029)
5. Phase 5: Agent Integration (T030-T039)
6. Phase 6: Queries + Validation (T040-T047)

🔄 Phase 1: Starting...
[Agent implements Phase 1]
✅ Phase 1: Complete

🔄 Phase 2: Starting...
[Agent implements Phase 2]
✅ Phase 2: Complete

...continues through all phases...

🎉 Autopilot Complete!

Notes

• Each phase runs as a separate subagent for isolation
• Phases execute sequentially to respect dependencies
• Progress is reported after each phase
• On failure, stops immediately to prevent cascading issues
• User can resume from failed phase with /implement "Phase N"