playbooks

home / skills / phrazzld / claude-config / autopilot

autopilot skill

/skills/autopilot

This skill automates end-to-end issue delivery by specing, designing, building, and shipping a draft PR from the highest-priority task.

npx playbooks add skill phrazzld/claude-config --skill autopilot

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.4 KB
---
name: autopilot
description: |
  Full autonomous delivery from issue to PR.
  Finds highest-priority issue, specs it, designs it, builds it, ships it.
  Use when: shipping an issue end-to-end, autonomous delivery, sprint execution.
  Composes: /spec, /architect, /build, /refactor, /update-docs, /pr.
argument-hint: "[issue-id]"
effort: high
---

# /autopilot

From issue to PR in one command.

## Role

Engineering lead running a sprint. Find work, ensure it's ready, delegate implementation, ship.

## Objective

Deliver Issue `$ARGUMENTS` (or highest-priority open issue) as a draft PR with tests passing.

## Latitude

- Codex writes first draft of everything (investigation, implementation, tests, docs)
- You orchestrate, review, clean up, commit, ship
- Flesh out incomplete issues yourself (spec, design)
- Never skip an issue because it's "not ready" — YOU make it ready

## Priority Selection

**Always work on the highest priority issue. No exceptions.**

1. `p0` > `p1` > `p2` > `p3` > unlabeled
2. Within tier: `horizon/now` > `horizon/next` > unlabeled
3. Within same horizon: lower issue number first
4. Scope, cleanliness, comfort don't matter — priority is absolute

## Workflow

1. **Find issue** — `gh issue view $1` or `gh issue list --state open --limit 20`
2. **Spec** — Invoke `/spec` if no `## Product Spec` section
3. **Design** — Invoke `/architect` if no `## Technical Design` section
4. **Build** — Invoke `/build` (branching, Codex implementation, commits)
5. **Refine** — `/refactor`, `/update-docs`, then `ousterhout` agent for module depth review
6. **Ship** — `/pr` with `Closes #N` (must satisfy all PR Body Requirements from `/pr` skill)

## Parallel Refinement (Agent Teams)

After `/build` completes, parallelize the refinement phase:

| Teammate | Task |
|----------|------|
| **Simplifier** | Run code-simplifier agent, commit |
| **Depth reviewer** | Run ousterhout agent, commit |
| **Doc updater** | Run /update-docs, commit |

Lead sequences commits after all teammates finish. Then `/pr`.

Use when: substantial feature with multiple refinement needs.
Don't use when: small fix where sequential is fast enough.

## Stopping Conditions

Stop only if: issue explicitly blocked, build fails after multiple attempts, requires external action.

NOT stopping conditions: lacks description, seems big, unclear approach.

## Output

Report: issue worked, spec status, design status, commits made, PR URL.

Overview

This skill performs full autonomous delivery from issue to draft PR. It finds the highest-priority open issue, writes a product spec and technical design if missing, implements the change with tests, refines the code and docs, and opens a draft PR with CI passing. It is designed for engineering leads who want one-command end-to-end shipping.

How this skill works

The skill inspects the repository issues and selects the absolute highest-priority open issue by label and horizon rules. It runs a sequence of sub-tasks: spec, architect, build, refactor, update-docs, and pr, creating branches, commits, tests, and documentation as needed. Parallel refinement with helper agents is supported after implementation, and the skill stops only for explicit blocks or persistent build failures.

When to use it

  • Ship an entire issue end-to-end without manual orchestration.
  • Execute sprint work as an engineering lead delegating to agents.
  • Turn an unclear or underspecified issue into a ready-to-ship PR.
  • Deliver features that require coordinated implementation, tests, and docs.
  • Run batch refinement using parallel agent teammates after a build.

Best practices

  • Always let the skill pick the highest-priority issue; do not override priority rules.
  • Review and clean the generated spec and design early to avoid rework during build.
  • Run parallel refinement (simplifier, depth reviewer, doc updater) for substantial features.
  • Keep an eye on CI and run multiple build attempts before declaring a failure.
  • Include 'Closes #N' in the PR body and ensure all PR body requirements are met before shipping.

Example use cases

  • Lead of a sprint needs to convert the next highest-priority issue into a draft PR with tests.
  • Feature work where the issue lacks a product spec or technical design and must be fleshed out.
  • Autonomous delivery for a multi-module change that benefits from parallel refinement agents.
  • When a small team wants consistent branch, commit, and PR structure without manual steps.
  • Recovering stalled work by making an unclear issue ready and shipping it.

FAQ

What issue will this skill work on?

It always selects the highest-priority open issue according to strict priority and horizon rules unless a specific issue argument is provided.

When does the skill stop working on an issue?

It stops only if the issue is explicitly blocked, the build fails after multiple attempts, or external action is required.

Can I run refinement tasks in parallel?

Yes — after build completes you can run simplifier, depth reviewer, and doc updater agents in parallel, then sequence commits and open the PR.