# Autopilot

> Full autonomous execution from idea to working code. Use when you want end-to-end autonomous development.

- Skill: `changhochien/autopilot` (Agent Skill)
- Install (CLI): `npx skillmds@latest add changhochien/autopilot`
- Raw SKILL.md: https://api.skillmd.com/api/skills/changhochien/autopilot/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: changhochien (https://skillmd.com/u/changhochien)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/changhochien/autopilot

---


# Autopilot Skill

Full autonomous execution pipeline: spec → plan → execute → QA → validate.

## Usage

```
/skill:autopilot "build a REST API for task management"
/skill:autopilot "create a user authentication system"
```

## Pipeline Phases

```
Phase 0: Requirements (deep-interview if vague)
Phase 1: Planning (architect + planner)
Phase 2: Execution (executor + parallel)
Phase 3: QA (tester + ultraqa)
Phase 4: Validation (verifier + reviewers)
Phase 5: Cleanup
```

## Phase 0: Requirements

If input is vague, use deep-interview first:

```
Input: "build me something cool"
→ Offer: Run deep-interview to clarify?
→ If yes: /skill:deep-interview → generates SPEC.md
→ If no: Proceed with analyst expansion
```

If input is clear, use explorer + analyst:

```
1. Explorer (haiku): Map relevant codebase areas
2. Analyst: Extract requirements from input
3. Architect: Create technical specification
Output: .omp/specs/autopilot-{slug}.md
```

## Phase 1: Planning

Create implementation plan:

```
1. Architect: Create plan based on spec
2. Planner: Break into tasks, estimate
3. Critic: Validate plan feasibility
Output: .omp/plans/autopilot-impl.md
```

## Phase 2: Execution

Implement using team or sequential:

```
Option A: /skill:team N:executor "implement plan"
Option B: Sequential executor passes

Execute independent tasks in parallel.
Run builds/tests in background (run_in_background: true).
```

## Phase 3: QA

Quality assurance cycling:

```
1. Tester: Add tests for new code
2. Build: npm run build
3. Typecheck: npx tsc --noEmit
4. Lint: npm run lint
5. Tests: npm test

If failures:
→ Fix issues
→ Repeat until all pass
→ Max 5 cycles, then escalate
```

## Phase 4: Validation

Multi-perspective review:

```
1. Architect: Functional completeness
2. Security-reviewer: Vulnerability check
3. Code-reviewer: Quality review

All must approve. Fix and re-validate on rejection.
```

## Phase 5: Cleanup

```
1. Delete state files
2. Summarize what was built
3. Report completion
```

## Configuration

Optional in `.omp/config.json`:

```json
{
  "autopilot": {
    "maxQaCycles": 5,
    "maxValidationRounds": 3,
    "pauseAfterPlanning": false,
    "skipQa": false,
    "skipValidation": false
  }
}
```

## Output Format

```
## Autopilot Complete

**Input:** "build a REST API for task management"
**Duration:** 45 minutes
**Phases:** 5/5 complete

### What Was Built
- REST API with CRUD endpoints
- PostgreSQL database
- JWT authentication
- Input validation
- Unit tests (85% coverage)

### Files Created
- src/api/tasks/: 5 files
- src/db/: 3 files
- tests/: 4 files

### Verification
- ✅ Build passes
- ✅ Tests pass (52/52)
- ✅ TypeScript clean
- ✅ Security review passed

### Next Steps
- Deploy to staging
- Add integration tests
- Document API with OpenAPI
```