Skip to main content
skill CX Codex

autopilot · sethgammon — Claude Code skill: what it does, how to install

autopilot processes queued tickets from .planning/intake/ through automated research, implementation, and verification.

MIT ★ 937 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local
Open on GitHub

What autopilot does

Autopilot scans .planning/intake/ for items marked as pending, briefed, or approved. For fresh items, it reviews guidelines in AGENTS.md and CLAUDE.md, documents risks, and prepares an execution brief. It then edits project files, running typecheck commands after every single change.

The process relies on Node scripts, invoking node scripts/deliver.js during preflight and node scripts/package-delivery.js to bundle finished work with a PR link. When .planning/intake/ is missing, the skill exits cleanly and points to /do setup.

This pipeline is limited to well-defined tasks of small or medium complexity. It will not handle long multi-session epics, parallel execution, or open-ended exploratory tasks.

What it helps with

  • process pending task files inside .planning/intake/
  • generate implementation briefs with scope and risk criteria
  • apply code modifications while checking types after each file update
  • package finished deliverables and attach PR review links

Example prompts for the agent

  • /autopilot
  • Process the next pending item in .planning/intake/
  • Run the delivery pipeline on .planning/intake/feature.md

How to install autopilot

1Plugin marketplace

/plugin marketplace add SethGammon/Citadel
/plugin install citadel@citadel-local

This installs the whole citadel plugin with all its skills

2Skills CLI (Vercel)

npx skills add SethGammon/Citadel --skill autopilot -a claude-code

3Manually: put the files in place

~/.claude/skills/autopilot/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/autopilot/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about autopilot

How to install autopilot in Claude Code?

Run /plugin marketplace add SethGammon/Citadel and then /plugin install citadel@citadel-local. You can also install it using npx skills add SethGammon/Citadel --skill autopilot -a claude-code.

What does autopilot do?

It reads tasks from .planning/intake/, creates structured briefs, edits code with continuous typecheck verification, and packages results.

When should autopilot not be used?

Avoid using it for multi-session campaigns, parallel workloads, or exploratory tickets without explicit requirements.

Source text

SKILL.md · MIT
---
name: autopilot
license: MIT
description: >-
  Intake-to-delivery pipeline. Processes pending items from .planning/intake/:
  briefs new ideas, executes approved work through research → plan → build → verify.
  Drop a file in .planning/intake/ and invoke this skill.
user-invocable: true
auto-trigger: false
trigger_keywords:
  - intake
  - process pending
  - pipeline
last-updated: 2026-03-20
---

# /autopilot — Intake Pipeline

## Orientation

Use Autopilot when:
- There are pending items in `.planning/intake/`
- You want to process intake items without manual orchestration
- The work is scoped and well-defined (Small or Medium complexity)

Do NOT use Autopilot for:
- Large, multi-session campaigns (use Archon)
- Parallel execution (use Fleet)
- Exploratory or open-ended work (use Marshal)

## Protocol

### Step 0: DELIVERY PREFLIGHT

When the user names a specific intake file or asks for "intake to PR", prefer
the deterministic delivery preflight before freeform build work:

```bash
node scripts/deliver.js --intake .planning/intake/{item}.md
```

If no specific intake file is named, use:

```
node scripts/deliver.js --next
```

This selects the highest-priority pending item in `.planning/intake/` and keeps
the golden path deterministic.

This creates an active campaign with claimed scope, acceptance criteria, map
context, and exit evidence rows, then marks the intake item `in-progress`.
Continue from the created campaign with `/do continue`.

After build and verification, package the delivery before marking the campaign
complete:

```bash
node scripts/package-delivery.js {campaign-slug}
```

If a PR exists, record the PR as the review target:

```bash
node scripts/package-delivery.js {campaign-slug} --pr https://github.com/{owner}/{repo}/pull/{number}
```

### Step 1: SCAN

Read all files in `.planning/intake/` and identify:
- `status: pending` → needs briefing
- `status: briefed` → ready to build
- `status: approved` → ready to build
- `status: in-progress` → check if stuck

### Step 2: BRIEF (for pending items)

For each pending item:

1. Read the intake file
2. Read related files mentioned in the description
3. Research the scope: what files exist, what patterns are established
4. Write the brief:
   - **Scope**: Small / Medium / Large
   - **Approach**: How to implement (2-3 sentences)
   - **Files**: Which files to create or modify
   - **Quality gates**: What must be true when done
   - **Risks**: What could go wrong
5. Update the item's status to `briefed`

### Step 3: BUILD (for briefed/approved items)

For each briefed item (smallest first):

1. Read the brief
2. Execute the approach:
   - Create or modify the listed files
   - Follow the project's conventions (CLAUDE.md)
   - Run typecheck after each change
3. Verify:
   - All quality gates pass
   - Typecheck clean
   - Tests pass (if applicable)
4. Update status to `completed`

### Step 4: REPORT

Output a summary of what was processed:

```
Autopilot processed {N} items:
  ✓ {item-1}: briefed → built → verified
  ✓ {item-2}: briefed
  ✗ {item-3}: blocked — {reason}
```

## Intake Item Format

```markdown
---
title: "Feature Name"
status: pending | briefed | approved | in-progress | completed
priority: normal | high
target: src/path/to/affected/area/
---

Description of what needs to be done...
```

## Fringe Cases

- **`.planning/intake/` is empty or does not exist**: Output "Nothing to process — `.planning/intake/` is empty. Drop a file there or run `/do setup` to initialize." Do not error.
- **Intake item has no clear action**: If the description is too vague to execute, ask the user one clarifying question or skip the item with a note: "Skipped — direction unclear. Update the intake file and re-run."
- **Item status is unrecognized**: Treat unknown statuses as `pending` and proceed through the brief → build flow.
- **Typecheck fails during build**: Record the failure in the item's status, move on to the next item, and report the blocker in the exit summary.
- **`.planning/` does not exist**: Output a setup hint and exit cleanly. Autopilot requires `.planning/intake/` to operate — if the directory is absent, treat as empty intake and suggest running `/do setup`.

## Contextual Gates

**Disclosure:** "Processing intake queue: N items pending. Will dispatch skills per item."
**Reversibility:** amber — processes intake items by dispatching other skills that may modify files; undo depends on dispatched skills
**Trust gates:**
- Any: review intake and briefing.
- Familiar (5+ sessions): autopilot runs autonomously on queued items; novices should review intake before running.

## Quality Gates

- Never build without reading the project guidance (AGENTS.md, then CLAUDE.md) first
- Run typecheck after every file change
- Mark items as completed only when verification passes
- If an item is blocked, record the reason and move on

## Exit Protocol

```
---HANDOFF---
- Processed {N} intake items
- Built: {list of completed items}
- Blocked: {list with reasons}
- Remaining: {count of items still pending}
---
```

© SethGammon · MIT · SethGammon/Citadel

Similar skills

All skills for Agent setup: memory, context, orchestration →

autopilot by other authors comes first.

autopilot Yeachan-Heo autopilot — a Claude Code skill that turns a two-to-three-line description into working, verified code. It walks through requirements, design, implementation, QA and validation without asking at every step. CX Codex +1 1,100installs autopilot nick-vels autopilot turns a dictated idea into a finished app, site, bot or feature in one dialogue: requirements, spec, tickets, subagents and blind acceptance, no per-stage approval. CX Codex +1 6,300installs autopilot H-mmer autopilot — a Claude Code skill that runs a hunt across all vulnerability classes for a target and keeps the agent from calling it done too early. CX Codex +1 ★ 1,298repo stars client-intake official anthropics Runs a structured client intake: practice-area questions, cross-area issue spotting, conflict flags and a formatted case summary. CX Codex +1 641installs gsd-ns-workflow open-gsd gsd-ns-workflow — a skill for Claude Code that routes development tasks through specific workflow phases. It triggers sub-skills for planning, execution, verification, and project advancement. CX Codex +1 574installs autopilot-loop ruvnet autopilot-loop — a skill that runs one iteration of an autonomous loop: checks progress, picks the next task, schedules the next wake. Use it when you want Claude to keep working without manual breaks between tasks. CX Codex +1 753installs agent-backlog-autopilot relatedb The agent-backlog-autopilot Claude Code skill takes one agent-backlog task from selection through a pull request. It pauses after the draft checks pass and waits for a human to mark the PR ready for review. CX Codex +1 ★ 423repo stars codex-project-autopilot Morecil codex-project-autopilot guides project creation from raw concept to handoff: conducts discovery quizzes, drafts three plan tiers, coordinates roles, and prepares deployment checklists. CX Codex ★ 1,596repo stars om-pr-autopilot open-mercato om-pr-autopilot is a Claude Code skill that checks an open PR and runs the matching sequence of skills. Ask it to finish a PR or identify the remaining work. CX Codex +1 3,300installs

From the same set55

The whole set →
session-handoff session-handoff turns the current session into a structured HANDOFF block so the next session can pick up work without re-auditing the project. CX Codex +1 ★ 937repo stars verify verify — a skill to self-test the Citadel hook pipeline during a live session. Exercises real tool calls (Write, Edit, Bash, Read), verifies that hooks fire, telemetry accumulates, and no errors occur. CX Codex +1 ★ 937repo stars unharness unharness is a Claude Code skill that plans Citadel removal from a project and keeps a portable archive. It runs on requests to remove Citadel or clean up the harness. CX Codex +1 ★ 937repo stars grill grill turns a vague plan into a sharp technical spec through one-question-at-a-time interview, each with a default answer you edit. CX Codex +1 ★ 937repo stars doc-gen doc-gen generates function comments, directory READMEs, and API references while following the project’s existing conventions. Use it when docs should explain code behavior rather than repeat signatures. CX Codex +1 ★ 937repo stars policy-enforcer policy-enforcer is a Claude Code subagent that checks proposed actions against Citadel’s rules and returns an allow-or-block verdict. Archon and Fleet spawn it before actions with low reversibility. CX Codex ★ 937repo stars systematic-debugging systematic-debugging stops trial-and-error edits by enforcing a four-phase root cause protocol and freezing code changes until hypotheses are tested. CX Codex +1 ★ 937repo stars decision-map Turn an unresolved idea into a Git-tracked decision map, then pick up the investigation in later sessions. Useful before work is ready to build. CX Codex +1 ★ 937repo stars

Project sponsors

Companies that keep this analytics open