# Autopilot

> Execute a feature from description to committed code using three parallel sub-agents: Architect, Builder, and Validator.

- **Type:** Skill
- **Install:** `agentstack add skill-eddiebelaval-squire-autopilot`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [eddiebelaval](https://agentstack.voostack.com/s/eddiebelaval)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [eddiebelaval](https://github.com/eddiebelaval)
- **Source:** https://github.com/eddiebelaval/squire/tree/main/skills/autopilot
- **Website:** https://id8labs.app

## Install

```sh
agentstack add skill-eddiebelaval-squire-autopilot
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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` to create a team named `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` tool with `team_name` set to the autopilot team:

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

| Situation | Action |
|-----------|--------|
| No test command found | Validator uses `tsc --noEmit` + `npm run build` only |
| Architect produces vague plan | Builder should ask Architect for specifics via SendMessage before implementing |
| Builder fails same error 3x | Team lead takes over that specific fix |
| Tests were passing, now failing | Builder must fix before next commit (no skipping) |
| Feature too large (10+ files) | Architect should split into phases in PLAN.md; Builder implements phase by phase |

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

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [eddiebelaval](https://github.com/eddiebelaval)
- **Source:** [eddiebelaval/squire](https://github.com/eddiebelaval/squire)
- **License:** MIT
- **Homepage:** https://id8labs.app

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-eddiebelaval-squire-autopilot
- Seller: https://agentstack.voostack.com/s/eddiebelaval
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.