autopilot

A Claude Code skill that ships a complete production-ready feature while you sleep. One command, eight phases, zero babysitting.

You hand it a vision. It plans, researches, designs, builds with TDD, attacks its own code, runs the full prod-readiness gate, commits atomically, and notifies you through whatever push and desktop channels you have configured when the diff is ready for review. It never pushes.

/autopilot Build a stripe-backed waitlist with magic-link confirmation

Walk away. Come back to clean commits, real tests, a review summary, and a decision log of every call it made on your behalf.

---

What it does

• Plans by invoking gstack/autoplan (CEO + design + eng + DX review) before writing a line of code.
• Researches unknowns via parallel subagents. Pluggable: context7 for library docs, Nia for code and papers, web search for live state. Only when reasoning cannot close the gap.
• Designs UI through frontend-design, with design-shotgun for greenfield variants. Always inspects the existing design system first.
• Builds with strict TDD. Failing test, real assertions, real services, atomic commits.
• Attacks the code with an adversarial subagent that targets edge cases, unicode, races, injection, authz, SSRF, idempotency, resource exhaustion.
• Gates every commit through typecheck, lint, build, full tests, dependency audit, secret scan, RLS verification, bundle budget.
• Commits to the current branch only. Never pushes. Never co-authors. You review the diff and push yourself.
• Notifies through your configured push channel + a local desktop banner, once.

Why

Most autonomous coding agents either skip steps or stop and ask. Both fail the same use case: you are away from your machine for six hours and want a real, reviewable diff when you come back. autopilot's contract is the opposite of polite. It makes the calls, logs them, and ships. Vision-level forks block; everything else gets a line in DECISION_LOG.md.

It is built around four invariants:

1. The user is not available during the run.
2. Production-ready is the only acceptable bar. No half-shipped state, no it.only, no mocked integration tests, no playwright.
3. Every autonomous decision is reversible by inspecting the diff.
4. The branch is never pushed. Review is mandatory.

Install

This is a Claude Code skill. Drop the directory into your skills path, or use the packaged .skill file.

# Option A: clone into your skills directory
git clone https://github.com/sam-siavoshian/autopilot ~/.claude/skills/autopilot

# Option B: install the packaged .skill
# Download autopilot.skill from the latest release, then in Claude Code:
#   /plugin install autopilot.skill

Verify Claude Code sees it:

/autopilot

If the slash command resolves, you are set.

Configuring notifications

scripts/notify.sh writes a structured .notify-queue.json describing what to send on each channel. The skill then invokes whatever push and notification MCP tools you have configured.

Out of the box it supports:

• Desktop banner via osascript on macOS, notify-send on Linux. Always on, local.
• Push channel (optional). Substitute your own: a Telegram bot, Pushover, ntfy, Discord webhook, or any MCP tool that sends to your phone.
• Voice / TTS (optional). Substitute your TTS MCP tool if you want spoken notifications.
• Wearable / HUD (optional). Substitute your HUD MCP tool if you have one.

The queue format is simple JSON, see references/notification.md for the schema and how to point it at your stack.

Usage

/autopilot <vision>

Trigger phrases the skill also responds to:

• autopilot ...
• ship this for me
• build this while I sleep
• you handle the whole thing
• take it and run

Be specific about what hurts and what success looks like. autopilot reads the vision word for word and saves it verbatim. Anything missing it tries to resolve through research before bothering you.

The eight phases

0. Bootstrap        capture vision, snapshot git, create run dir
1. Plan             /autoplan (CEO + design + eng + DX)
2. Research blitz   parallel subagents (only when needed)
3. UX and design    /frontend-design, optional /design-shotgun
4. TDD build        failing test, minimum code, atomic commit
5. Adversarial      try to break it: edges, security, races
6. Prod gate        /code-review high, /cso, full prod_check.sh
7. Commit           atomic commits on current branch (no push)
8. Notify           push + desktop banner (your configured channels)

Each phase is detailed in references/workflow.md.

What you get back

Inside ~/.autopilot/runs/<slug>-<timestamp>/:

• vision.md, your prompt, verbatim
• plan.md, the reviewed plan from /autoplan
• research/, one markdown file per topic, cited
• design/, HTML mocks if the work touches UI
• screenshots/, visual verification at 320 / 768 / 1280 px
• RUN_LOG.md, phase-by-phase timeline
• DECISION_LOG.md, every autonomous call with reasoning, alternatives, reversibility
• REVIEW_SUMMARY.md, TL;DR, commit list, diff stat, what to verify, how to revert
• BLOCKED.md, only if a hard stop fired

Plus atomic conventional-commit history on your current branch.

When it stops

autopilot never blocks for a question that reasoning, research, or a test could answer. It only halts on four hard-stop categories:

1. Vision-level conflict it cannot reconcile from context
2. Missing credentials for a third-party service
3. Schema-breaking change to a shared public contract
4. Three failed root-cause attempts on the same bug

When it halts, you get a BLOCKED.md describing what was tried, why it cannot resolve autonomously, and the smallest decision needed. Full rules in references/decision-rules.md.

What it will not do

• Push to a remote
• Create or merge a pull request
• Run destructive shell commands without an explicit decision-log entry
• Co-author commits
• Use Playwright
• Mock an integration test for a service that is actually reachable
• Leave a half-shipped feature flag toggled to a broken state

Bundled rules

The skill ships with a reference library that future-you (and reviewers) can read:

• workflow.md, the eight phases in detail
• research-protocol.md, which tool answers which question
• testing.md, real test standards, banned tools
• prod-readiness.md, the full pre-commit gate
• decision-rules.md, when to decide, when to stop
• notification.md, multi-channel notify protocol
• ui-protocol.md, design defaults and anti-slop rules
• security.md, OWASP-aligned per-change checklist

Requirements

• Claude Code (the CLI)
• macOS (for osascript notifications), or Linux with notify-send
• bun, python3, git, gh (recommended)
• Optional: any MCP server providing a push, TTS, or HUD tool

Status

Early. Open to issues and PRs that keep the contract intact: production bar, no slop, branch-local only.

License

MIT. See LICENSE.