Autopilot — Autonomous Parallel Build Pipeline

Core Workflows

Workflow 1: Primary Action

1. Analyze the input and context
2. Validate prerequisites are met
3. Execute the core operation
4. Verify the output meets expectations
5. Report results

Execute a feature from description to committed code using three parallel sub-agents: Architect, Builder, and Validator. No approval pauses — full autonomous execution.

Usage

/autopilot "Add user authentication with email OTP"
/autopilot "Implement dark mode toggle with system preference detection"
/autopilot "Add Stripe billing with tiered pricing"

The argument is a plain-English feature description. The more specific, the better the output.

Instructions

When invoked with a feature description:

Step 0: Pre-Flight

1. Confirm the project context. Read the current directory, identify the project (check for package.json, CLAUDE.md, etc.), and state: "Running autopilot for [PROJECT] on branch [BRANCH]."
2. Detect the test command. Check package.json scripts for

   test

   ,

   test:unit

   ,

   vitest

   ,

   jest

   , or

   playwright

   . If no test command exists, note that Validator will run

   npx tsc --noEmit

   and

   npm run build

   instead.
3. Detect the build command. Check for

   build

   ,

   build:dev

   , or

   next build

   in package.json scripts.

Step 1: Create the Team

Use

TeamCreate

autopilot-{timestamp}

Then create three tasks with dependencies:

Task 1 — Architect

Subject: "[Autopilot] Architect: Write implementation plan"
Description: |
  Read the codebase to understand architecture, patterns, and conventions.
  Write a detailed implementation plan to PLAN.md in the project root.

  The plan MUST include:
  - Files to create or modify (with full paths)
  - Implementation order (what depends on what)
  - Key design decisions with rationale
  - Type signatures for new functions/components
  - Test cases to verify the feature works

  Feature: {FEATURE_DESCRIPTION}

  Read at minimum: package.json, tsconfig.json, CLAUDE.md (if exists),
  the src/ directory structure, and any files related to the feature area.

  Do NOT implement anything. Only produce PLAN.md.
ActiveForm: "Architecting implementation plan"

Task 2 — Builder (blocked by Task 1)

Subject: "[Autopilot] Builder: Implement feature from plan"
Description: |
  Read PLAN.md and implement each section sequentially.

  Rules:
  - Implement one logical unit at a time (one component, one API route, etc.)
  - After each logical unit, run `npx tsc --noEmit` to verify it compiles
  - If it compiles, commit with message: "[Autopilot] feat: {what was built}"
  - If it fails, fix the error before moving on
  - Follow existing codebase patterns exactly (imports, naming, file structure)
  - Do NOT refactor unrelated code
  - Do NOT add comments unless the logic is non-obvious

  Feature: {FEATURE_DESCRIPTION}
ActiveForm: "Building feature from plan"

Set

addBlockedBy: [Task 1 ID]

Task 3 — Validator (blocked by Task 1)

Subject: "[Autopilot] Validator: Continuous test verification"
Description: |
  Wait for Builder to start committing, then continuously validate:

  1. Run the test suite: {TEST_COMMAND}
  2. Run the build: {BUILD_COMMAND}
  3. Run type checking: npx tsc --noEmit

  If ANY check fails:
  - Report the exact failure to the Builder via SendMessage
  - Wait for the fix commit
  - Re-run all checks

  If all checks pass after Builder marks their task complete:
  - Mark this task as completed
  - Send a summary of all test runs to the team lead

  Keep running until Builder is done. Do not stop after one pass.
ActiveForm: "Validating builds and tests"

Set

addBlockedBy: [Task 1 ID]

Step 2: Launch Agents

Spawn three agents using the

Task

team_name

1. Architect agent —

   subagent_type: "general-purpose"

   , assign Task 1
2. Builder agent —

   subagent_type: "general-purpose"

   , assign Task 2
3. Validator agent —

   subagent_type: "general-purpose"

   , assign Task 3

Launch Architect first. Launch Builder and Validator after Architect completes (they are blocked until then).

Step 3: Monitor and Coordinate

As team lead:

• When Architect completes, unblock Builder and Validator
• Route Validator failure messages to Builder
• If Builder gets stuck (same error 2+ times), intervene directly
• Track progress via TaskList

Step 4: Wrap Up

When all three tasks are completed:

1. Read the final PLAN.md and compare against what was built
2. Run one final validation: build + tests + type check
3. Delete PLAN.md (it served its purpose — the commits tell the story)
4. Output a summary:

Autopilot Complete
==================
Feature: {FEATURE_DESCRIPTION}
Files created: {count}
Files modified: {count}
Commits: {count}
Tests: {PASS/FAIL}
Build: {PASS/FAIL}

Commits:
- {commit hash} {message}
- {commit hash} {message}
...

5. Shut down the team with

   TeamDelete

Failure Modes

tsc --noEmit

npm run build

What This Skill Does NOT Do

• Push to remote (you decide when to push)
• Create PRs (use

  /commit-push-pr

  for that)
• Modify unrelated code
• Skip failing tests
• Ask for approval mid-execution