convez.ai
SkillProdutividadeAvançado
cookys

Autopilot — Orquestração de Ciclo de Vida para Claude Code

cookys/autopilot

Orquestração estratégica e lifecycle management para fluxos de desenvolvimento em Claude Code

Ver no GitHub
BomPluginScore · de 0 a 100

Suite de 19 skills que adiciona gerenciamento de ciclo de vida, decisões estratégicas, gates de qualidade e disciplina metodológica ao Claude Code. Funciona standalone e coexiste graciosamente com o plugin Superpowers, oferecendo recursos como dimensionamento de tarefas, pesquisa dual-agente, debate estratégico e pipelines de qualidade unificados.

Instalação

$npx convez-ai cookys/autopilot

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
12
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 dia
Versão
—
Issues abertas
0
Contribuidores
4

Casos de uso

  • Dimensionar e rastrear tarefas de desenvolvimento com regras de sessão
  • Conduzir pesquisa dual-agente (pesquisador + cético) em problemas técnicos
  • Executar debates estratégicos (think-tank, dialética Hegeliana) para decisões de alto risco
  • Implementar pipelines de qualidade unificados (teste → scan → completude → review)
  • Capturar conhecimento, retrospectivas e melhorias contínuas de projeto

Veredito

Autopilot é uma solução robusta para times que precisam de estrutura metodológica e orquestração estratégica além da execução tática. Excelente para projetos com ciclos complexos, decisões de alto risco e necessidade de disciplina de qualidade — requer familiarity com Claude Code e mentalidade de engenharia de processos.

README

A tradução para o português deste README ainda está na fila.


The Problem

Claude Code on its own — even with the built-in superpowers plugin if you've installed it — leaves several layers unaddressed:

  • Lifecycle management — no task sizing, no project tracking, no session start/end discipline
  • Strategic decisions — no multi-perspective debate, no dual-agent research
  • Quality gates — no unified pipeline enforcing test → scan → completeness → review
  • Methodology discipline — evidence-first debugging, test pyramid baselines, team allocation, performance profiling all need explicit frames
  • Self-improvement — no knowledge capture, no retrospectives, no "what's next?" recommendations
  • Project-specific context — no mechanism to inject your project's tools, conventions, and known gotchas

The Solution

Autopilot ships 19 skills covering lifecycle orchestration, strategic intelligence, methodology, and quality gates. Works standalone; coexists with the optional superpowers plugin (see Superpowers Coexistence below).

SkillWhat It DoesCoexists with
dev-flowSizes tasks (S/L/H), sets session rules for config injection and quality gates, manages project trackingsuperpowers:writing-plans (planning)
surveyDual-agent research (researcher + skeptic)— (no equivalent)
brainstormPre-code Socratic design exploration — discovers options when none exist yet, surfaces 2-3 approaches, gates implementation until a design is approvedsuperpowers:brainstorming (internalized)
think-tank6-role debate for strategic decisionssuperpowers:brainstorming (different level — requirements exploration)
think-tank-dialecticHegelian dialectic for irreversible / high-stakes decisions with LOW consensus. 4 职能 + 2 adversarial roles (Popper falsifier + Munger inverter). NOT a "better think-tank" — a different tool for a different situation— (no equivalent)
ceo-agentAutonomous execution with CEO-level judgment— (no equivalent)
research-to-shipPinned participatory pipeline: research best-practice → plan → dialectic loop review → project → dev-flow, with a human gate between each phase. Delegates to survey/think-tank-dialectic/project-lifecycle/dev-flow— (no equivalent)
quality-pipelineUnified quality gate: test → scan → completeness → reviewsuperpowers:verification-before-completion (partial)
finish-flowSize-aware closing forcing function — TaskCreates discrete L-5 / H-9 / Fix / S-Lite sub-tasks so nothing gets silently compressed— (no equivalent)
project-lifecyclePlan → bootstrap → structure → archivesuperpowers:finishing-a-development-branch (partial)
learnAuto-records knowledge from failures; knowledge health audit— (no equivalent)
retroEngineering retrospective from git history— (no equivalent)
distillDistills recurring procedures/corrections from your conversation history into your own personal skills (routed to a private @skills-dir pack / project dirs, never into autopilot)— (no equivalent)
nextScan all work sources, recommend highest-priority task— (no equivalent)
auditSystematic comparison between implementations— (no equivalent)
debugEvidence-first debugging methodology (tool → log → code) with Three Red Linessuperpowers:systematic-debugging (broader hypothesis-driven framing)
test-strategyTest pyramid, baseline 守則, failure investigation funnel — not TDD (orthogonal scope)superpowers:test-driven-development (coding loop, complementary not equivalent)
teamTeam allocation decisions: when to組隊, role selection, dependency analysissuperpowers:dispatching-parallel-agents (dispatch mechanism — the verb to autopilot:team's noun)
profilingEvidence-first performance profiling (only methodology entry point in the ecosystem)— (no superpowers equivalent)

Coexistence Model — autopilot is standalone-capable, Superpowers is optional

Autopilot works fully without superpowers. If you also have superpowers installed, autopilot's orchestrator skills (ceo-agent, finish-flow, quality-pipeline, think-tank{,-dialectic}, dev-flow) consult .claude/dispatch-config.md to decide which methodology / reviewer / parallel dispatcher to delegate to.

autopilot:dev-flow sets session rules:
  → "When debugging, read .claude/debug-config.md for project context"
  → "Before committing, run autopilot:quality-pipeline"
  → "On session end, update project tracking"

Methodology dispatch (per .claude/dispatch-config.md):
  → Debugging:  superpowers:systematic-debugging (if installed) → autopilot:debug
  → Testing:    superpowers:test-driven-development + autopilot:test-strategy (complementary)
  → Profiling:  autopilot:profiling (no superpowers equivalent)
  → Team:       autopilot:team (allocation) + superpowers:dispatching-parallel-agents (dispatch)
  → Review:     autopilot:reviewer → superpowers:code-reviewer (fallback)

This was historically positioned as「sets the rules; Superpowers executes」(v2.0-v2.6); v2.7.0 preserves that model when superpowers is installed while making autopilot also work as a standalone plugin. See Superpowers Coexistence for per-scenario UX.


Superpowers Coexistence

Autopilot supports three deployment scenarios:

A. You have superpowers installed (user-level or marketplace)

Recommended default. autopilot's orchestrators delegate tactical execution to superpowers via .claude/dispatch-config.md chains.

.claude/dispatch-config.md example (paste into your project):

## Code Review
- autopilot:reviewer
- superpowers:code-reviewer

## Parallel Dispatch
- superpowers:dispatching-parallel-agents
- native

## Methodology Preferences

### Debugging
- superpowers:systematic-debugging
- autopilot:debug

### Testing methodology
- autopilot:test-strategy
- superpowers:test-driven-development

B. You do NOT have superpowers installed

Autopilot runs fully standalone. Orchestrators fall through to autopilot's own fallback skills (autopilot:debug, autopilot:test-strategy, autopilot:team, autopilot:profiling) and native parallel dispatch (multiple Task tool calls in one response).

No .claude/dispatch-config.md needed — the defaults documented at the top of project-config-template/dispatch-config.md match this scenario.

C. You have superpowers user-level but want pure-autopilot in a specific project

Use .claude/settings.json's disabledSkills to hard-cut superpowers skills per-project:

{
  "disabledSkills": [
    "superpowers:systematic-debugging",
    "superpowers:test-driven-development",
    "superpowers:dispatching-parallel-agents",
    "superpowers:code-reviewer"
  ]
}

This is a Claude Code native mechanism; autopilot doesn't need a config flag for it.

Migration note (v2.6.0 → v2.7.0)

If you upgrade from v2.6.0 and previously removed debug, test-strategy, team, or profiling entries from your CLAUDE.md skill routing tables (expecting these skills to remain absent), be aware they're back as fallback skills in v2.7.0 and may now trigger on the corresponding keywords. To suppress: add them to .claude/settings.json's disabledSkills.


Key Features

Three Modes of Operation

Autopilot provides three distinct cognitive modes for different situations:

dev-flow — Guided Development (default)

The entry point for all development tasks. Evaluates task size and routes accordingly:

You: "Add WebSocket compression"

Claude (with dev-flow):
  1. Size assessment: L (crosses network + protocol + client modules)
  2. → Creates plan, project directory, feature branch
  3. → Implements phase by phase, quality gate each phase
  4. → Archives project on completion

Claude (without dev-flow):
  → Starts grep-ing the codebase immediately
  → No plan, no phases, no quality gates

dev-flow also handles the session lifecycle — health checks on startup, knowledge review, goal alignment on context continuation. You don't invoke these separately; dev-flow absorbs them.

ceo-agent — Autonomous Execution

When you want outcomes, not involvement. The agent becomes CEO; you become the Board.

You: "CEO mode. Handle the reconnect system. Level 3, you decide everything."

CEO startup:
  1. OKR — concrete success criteria (not vague "make it work")
  2. Involvement level — how often to report (every step / phase / just results)
  3. Scope mode — Expand / Selective / Hold / Reduce
  4. No-go zones — what's absolutely off-limits

Then: autonomous execution within DOA (Delegation of Authority)

The CEO agent applies 10 cognitive patterns from great CEOs (Bezos's two-way doors, Munger's inversion reflex, Jobs's focus as subtraction) and follows the Boil the Lake principle — AI makes completeness nearly free, so always choose the complete implementation over shortcuts.

CEO cannot self-audit. Like corporate governance, quality-pipeline and code-review run independently.

think-tank — Multi-Perspective Debate

For strategic decisions where a single perspective isn't enough. 6 roles debate in parallel:

You: "Should we rewrite the auth system or patch it?"

Think Tank assembles:
  - CTO (technical feasibility)
  - Product Director (user impact)
  - QA Lead (risk assessment)
  - Security Architect (threat model)
  - Customer Advocate (user experience)
  - Operations (deployment/maintenance)

Output: Decision Brief with consensus, dissenting views, and recommendation

How They Work Together

 user task
    │
    ▼
 dev-flow ──────────────────────────────────────────────┐
    │                                                    │
    ├─ S (small): implement → quality-pipeline → commit   │
    │                                                    │
    └─ L (large): project-lifecycle (bootstrap)          │
         │         → per-phase implement                 │
         │         → quality-pipeline per phase           │
         │         → project-lifecycle (archive)          │
         │                                               │
         ├─ needs research? ──→ survey                   │
         ├─ strategic decision? ──→ think-tank            │
         ├─ user says "handle it"? ──→ ceo-agent         │
         │                                               │
         └─ session end ──→ learn (capture knowledge)    │
                            retro (periodic review)      │
                                                         │
 what's next? ──→ next (scan → rank → recommend)         │
                                                         │
 ◄───────────────────────────────────────────────────────┘

Skill Boundaries

Decision TypeUse This
Technical choice (X library vs Y)survey — external research with dual perspective
Strategic choice (should we? how big? what first?)think-tank — internal multi-role debate
User wants outcome, not involvementceo-agent — autonomous execution
User wants to participatedev-flow — guided workflow with checkpoints

Install

Claude Code (primary)

/plugin marketplace add cookys/autopilot
/plugin install autopilot@autopilot

All 19 skills available immediately as autopilot:dev-flow, autopilot:survey, etc.

OpenCode (.agents/skills/ auto-scan)

Clone the repo anywhere; OpenCode native skill scanner picks up .agents/skills/ from cwd.

git clone https://github.com/cookys/autopilot.git
cd autopilot
./scripts/setup-symlinks.sh                          # ensure .agents/skills/ symlink resolves (no-op on Linux/macOS/WSL)
cd .opencode && npm install                          # for @opencode-ai/plugin types (optional unless editing the TS plugin)
cd ..
opencode debug skill | grep autopilot                # verify autopilot skills discovered

Agents (autopilot-reviewer, autopilot-debugger, autopilot-planner) load via .opencode/opencode.json automatically.

Codex (OpenAI)

Same .agents/skills/ symlink as OpenCode — Codex's skill scanner walks up from cwd to find <repo>/.agents/skills/. No further setup needed for per-repo usage.

For global availability across repos, see platforms/codex/config.toml.example.

Antigravity (agy)

agy imports autopilot as a Claude Code-source plugin (verified against agy 1.0.1 — there is no loose skills-dir scan; the older ~/.gemini/antigravity/skills/ approach was superseded).

./scripts/install-antigravity.sh                     # agy plugin validate → install → list
agy plugin list | grep autopilot                     # verify it's registered
# remove with: agy plugin uninstall autopilot

Windows

Repo-tracked symlinks (.agents/skills/) require Developer Mode + core.symlinks=true before cloning:

git config --global core.symlinks true               # one-time, system-wide
# Enable Developer Mode: Settings -> Privacy & security -> For developers
git clone https://github.com/cookys/autopilot.git
cd autopilot
.\scripts\setup-symlinks.ps1

Without these, symlinks materialise as plain text files containing the target path — setup-symlinks.ps1 will detect and try to repair, but Developer Mode is still required for the repair.

Cross-platform pre-commit gate

./scripts/install-hooks.sh                           # one-time per clone

Activates .githooks/pre-commit which runs sync-version.js --check and sync-agent-bodies.sh --check to catch version-manifest drift and agent-body drift before they reach the remote.


Cross-Repository Configuration (Injection)

Skills work out of the box with sensible defaults. For project-specific behavior, drop a markdown file into your project's .claude/ directory — the skill reads it at invocation time via Claude Code's !command`` preprocessor.

How Injection Works

┌─────────────────────────────────┐
│  Plugin (shared, read-only)     │   Autopilot skills live here.
│  ~/.claude/plugins/cache/       │   Same for all projects.
│  autopilot/skills/dev-flow/     │
│           └── SKILL.md ─────────┼──┐
└─────────────────────────────────┘  │
                                     │  At invocation, SKILL.md runs:
                                     │  !`cat .claude/dev-flow-config.md`
                                     │
┌─────────────────────────────────┐  │
│  Your Project (per-repo)        │  │
│  my-project/.claude/            │◄─┘  Reads from YOUR project's
│    ├── dev-flow-config.md       │     .claude/ directory
│    ├── quality-gate-config.md   │
│    ├── skill-routing.md         │     These files are plain markdown.
│    └── team-config.md           │     No schema. No YAML. Natural language.
└─────────────────────────────────┘

The !command`` syntax is a Claude Code preprocessor — it runs a shell command and inlines the output into the skill body before the LLM sees it. This means:

  • No config file? Silent pass-through — the skill works normally without extra noise. Zero friction.
  • Config is natural language. A markdown file is more expressive than YAML — you can write rules, exceptions, and rationale in prose.
  • Config is project-local. Each repo has its own .claude/ directory. The same autopilot plugin adapts to a C++ game server, a React app, or a Rust CLI — all through different config files.
  • Session rules inject config for ALL activities. dev-flow sets rules like "when debugging, read .claude/debug-config.md" — so even Superpowers' debugging skill gets your project context.

Available Config Files

Config FileCustomizesTemplate
.claude/dev-flow-config.mdSize rules, quality gates, build commands, special rulestemplate
.claude/finish-flow-config.mdL-5 / H-9 closing sequence overrides (merge target, archive proc, per-size quality gate)template
.claude/quality-gate-config.mdTest, scan, and review commandstemplate
.claude/project-lifecycle-config.mdProject paths, bootstrap/archive scriptstemplate
.claude/next-config.mdWork source paths for the next skilltemplate
.claude/team-config.mdTeam role templates for your tech stacktemplate
.claude/test-strategy-config.mdTest commands, pyramid ratios, coverage thresholdstemplate
.claude/debug-config.mdProject-specific debug tools and log pathstemplate
.claude/profiling-config.mdProfiling tools and metrics collectiontemplate
.claude/skill-routing.mdMap keywords to your project's domain skillstemplate
.claude/model-routing-config.mdSubagent model/mode per role (planner, reviewer, etc.)template
.claude/loop.mdDefault prompt for a bare /loop — unattended babysit of the current branch (CI/PR tending → next/debug/quality-pipeline). Claude Code only (v2.1.72+); degrades cleanly elsewhere.template

Example: C++ Game Server Config

# Dev Flow — TWGameServer Config

## Size Rules
- **S**: single module, no interface change → direct commit
- **L**: 3+ modules, public interface, Feature Flag → plan + project + PR

## Quality Gate
- S: `node .claude/scripts/quality-pipeline.js --size S`
- L: `node .claude/scripts/quality-pipeline.js --size L` per phase

## Build & Deploy
- Build: `../deploy/scripts/dev.sh build`
- Build+Restart: `../deploy/scripts/dev.sh br`

## Special Rules
- Commit 前必須跑 E2E if 改了遊戲邏輯
- Proto 改動要重編譯 SDK

Example: Skill Routing

# Skill Routing

| Keyword | Invoke |
|---------|--------|
| MJ / mahjong | `twgs-game-dev` → references/mj.md |
| crash / core dump | `twgs-debug` |
| proto / protobuf | `twgs-protobuf` |
| stress / 10K | `twgs-stress-test` |

This lets autopilot's dev-flow automatically invoke your project's domain-specific skills when it encounters relevant keywords — bridging the generic workflow layer with project-specific knowledge.


Team Setup

Add to your project's .claude/settings.json so team members get prompted to install:

{
  "extraKnownMarketplaces": {
    "autopilot": {
      "source": { "source": "github", "repo": "cookys/autopilot" }
    }
  }
}

Known Limitation

Claude Code plugins are pinned to a specific commit at install time. /plugin update may not detect new versions. To get the latest:

/plugin uninstall autopilot@autopilot
/plugin marketplace remove autopilot
/plugin marketplace add cookys/autopilot
/plugin install autopilot@autopilot

See anthropics/claude-code#31462 for details.


Design Philosophy

Why a plugin, not copy-paste skills? Copy-pasted skills drift within weeks. A plugin gives you a single source of truth — update once, everyone gets it via /plugin update.

Why 19 skills + 14 hooks? v2.0 removed 4 skills (debug, test-strategy, team, profiling) that overlapped with superpowers skills, on the assumption that superpowers was always installed. v2.7.0 restores them as standalone fallbacks (with explicit ## Coexistence with Superpowers sections in their bodies explaining the relationship) so autopilot works without superpowers. When superpowers IS installed, .claude/dispatch-config.md chains let orchestrators prefer the superpowers equivalent for runtime delegation; the autopilot skill stays in the catalog as the standalone fallback. v2.2 added think-tank-dialectic as a different tool (not an upgrade) for irreversible decisions. v2.5 added 14 hooks for runtime enforcement — discipline that was previously only in markdown rules. Hooks and skills serve different layers: skills set rules at conversation time; hooks enforce them at tool-call time.

Why !command`` injection, not config files? In the Claude Code world, "configuration" is natural language. A markdown file read at invocation time is more expressive than YAML, requires no schema, and degrades gracefully when absent.

How does it work with Superpowers?

Autopilot is the rule-setter; Superpowers is the executor. They coexist through a layered triggering design:

Layer 1 — CLAUDE.md routing table (project-level)
  "新功能規劃 → autopilot:dev-flow"
  "技術調研 → autopilot:survey"
  Maps project context to skills. Written by the user.

Layer 2 — using-superpowers skill (session-level)
  "Check skills BEFORE any response. Even 1% chance = invoke."
  This is what makes skill triggering work. Without it,
  the model answers directly and never checks skills.

Layer 3 — Skill description (skill-level)
  "Use when: 'compare X with Y', 'check X against Y'..."
  User-intent trigger phrases help the model match
  the user's words to the right skill.

All three layers must work together. Layer 2 (Superpowers' using-superpowers) creates the habit of checking skills; Layer 1 (CLAUDE.md) provides project-specific routing; Layer 3 (descriptions) provides the semantic match. Autopilot never dispatches to or wraps Superpowers skills — they share the session, not a call chain.

Why do descriptions use quoted trigger phrases?

Skill descriptions serve Layer 3 — they're the last-mile match between user intent and skill selection. We write them in user-intent language ("what should I work on", "get it done", "let's debate this") rather than internal mechanics ("global work recommender", "autonomous execution mode") because the model matches user messages against descriptions. The closer the description mirrors what users actually say, the more reliable the trigger.


Methodology Agents

Autopilot ships three read-only methodology agents (v2.4.0) that carry Three Red Lines discipline into agent-level execution. Autopilot skills dispatch them automatically; you rarely invoke them directly.

AgentPurposeModelDispatched by
autopilot:reviewerPre-commit / pre-merge review, security audit, plan critique. Severity-tiered findings with file:line citations and ✅ Verified Clean sectionopusquality-pipeline, ceo-agent, finish-flow
autopilot:debuggerEvidence-first root-cause analysis. 5-phase methodology with PUA trigger on 2+ failures. Produces Proposed Fix as diff, never applies patchesopusquality-pipeline (round-trip), ceo-agent, dev-flow
autopilot:plannerSix-element Task Prompt decomposition for L-size work (goal / scope / input / output / acceptance / boundaries). Cannot write codesonnetdev-flow, think-tank

All three are physically read-only — their tools frontmatter excludes Edit and Write, so Claude Code mechanically prevents them from patching files. They produce findings, proposals, or plans, and hand off to the calling skill via a unified ### Handoff section with an enum-based Next consumer field.

The three agents carry autopilot's Three Red Lines into the agent layer:

  1. Closure — every finding has impact + fix direction, no open-ended output
  2. Fact-driven — every claim cites file_path:line_number; "probably" / "likely" are violations
  3. Exhaustiveness — full checklists run; clean items explicitly listed; silent omission is a violation

See agents/README.md for dispatch boundary, unified Output Contract, enum grammar, and the "autopilot methodology / voltagent role / project-specific" layer cake.


Recommended Companions

Autopilot is self-sufficient for methodology and lifecycle — install autopilot alone and you get all 19 skills + 3 methodology agents. For role-specialized work (language experts, database admins, Kubernetes specialists, frontend designers), we recommend installing voltagent alongside:

/plugin install voltagent@...

Autopilot and voltagent are orthogonal by design:

LayerWhat it doesWhere to look
MethodologyThree Red Lines discipline, evidence-first debugging, Seven-Element dispatch + six-element Planner decomposition contract, lifecycle orchestrationautopilot (this plugin)
RoleLanguage experts, infra specialists, domain experts (80+ agents)voltagent
ProjectYour tech stack's pitfalls, team conventions, domain-specific agents<project>/.claude/agents/

Dispatch boundary:

  • Going through an autopilot skill (quality-pipeline, dev-flow, ceo-agent) auto-dispatches autopilot methodology agents — :debugger and :planner named directly by their consumer skills, reviewer selected via the .claude/dispatch-config.md ## Code Review chain (defaults to autopilot:reviewer when chain unset or no entry dispatchable) — to carry methodology discipline into every invocation
  • Directly invoking an agent via the Agent tool — voltagent's role agents (voltagent-qa-sec:code-reviewer, voltagent-lang:rust-engineer, voltagent-data-ai:postgres-pro, etc.) are usually the better primary choice because they have broader domain coverage

Two workflows, two dispatch paths, zero overlap in practice.

Autopilot does not runtime-detect voltagent. :debugger and :planner are named directly by their consumer skills; the reviewer is selected via the .claude/dispatch-config.md ## Code Review chain with autopilot:reviewer as the default fallback when the chain is unset or no chain entry is dispatchable. If you want a reviewer not in the chain for a one-off task, invoke it explicitly via the Agent tool — that is a user-layer choice on top of the chain mechanism.


Hooks

Autopilot ships 14 hooks (shipped in v2.5.0) that enforce development discipline at the Claude Code runtime layer — no self-discipline required.

Tier A — Default-On (8 hooks)

These activate automatically when the plugin is installed. All are non-destructive and safe for any project.

HookEventWhat It Does
large-file-warnerPreToolUse/ReadWarns at 500KB, hard blocks at 2MB. Bypasses if offset/limit specified
suggest-compactPostToolUse/Write|EditCounts tool calls per session; suggests /compact at 50, then every 25
cost-trackerStopLogs token usage + estimated USD cost to ~/.claude/metrics/costs.jsonl
audit-logPostToolUse/BashLogs bash commands with auto secret redaction
session-summaryStopWrites git status + recent commits to ~/.claude/sessions/
log-errorPostToolUse/*Detects error keywords in tool output, appends to ~/.claude/error-log.md
commit-secret-scanPreToolUse/BashScans staged content for API keys/tokens. Hard blocks git commit if found
branch-protectionPreToolUse/BashBlocks force push and direct commits on main/master (anchored regex, env override)

Tier B — Opt-In (6 hooks)

Enable individually by copying entries from settings.example.json to your settings.json.

HookEventWhat It Does
config-protectionPreToolUse/Write|EditBlocks edits to linter/formatter config files
check-consoleStopWarns about console.log in modified JS/TS files
accumulator + batch-formatPostToolUse + StopBatch Prettier + tsc on all edited files at session end
test-runnerPostToolUse/Write|EditAuto-runs sibling test files on edit (vitest/jest)
design-qualityPostToolUse/Write|EditWarns on generic template UI patterns
mcp-healthPreToolUse + PostToolUseFailureExponential backoff for unhealthy MCP servers

Secret Detection

commit-secret-scan and audit-log share a unified secret pattern module (hooks/_shared/secret-patterns.js) covering: OpenAI, Anthropic, GitHub (PAT/OAuth/App), AWS, Google API, Slack, Stripe tokens + inline --token/password/Authorization patterns.

Override

  • Disable a Tier A hook: set autopilot.<hookName> = false in settings.json
  • Custom protected branches: set AUTOPILOT_PROTECTED_BRANCHES env var or autopilot.protectedBranches in settings
  • Disable cost tracking: set autopilot.costTracker = false

Inspired By

  • Task-tree engine prior art (v2.16.0) — the externalized-state substrate and its guardrails absorb published lessons rather than reinventing failures: append-only event log + derived index over read-modify-write node files (Steve Yegge's Beads postmortem; TaskMaster schema/concurrency incident reports — community issue-tracker reports surveyed 2026-06-12; no single canonical URL recorded at survey time), per-event schema_version with lazy migrations (LangGraph's versioned-state lesson; Temporal's history-evolvability model), and cheap cross-family judge panels over a single large judge (the PoLL result — Verga et al. 2024, "Replacing Judges with Juries"). All quantitative thresholds from these sources are treated as factory defaults pending local calibration, never as justification.
  • gstack — Garry Tan's skill suite for Claude Code. The CEO agent's cognitive patterns (Bezos doors, Munger inversion, Jobs subtraction), Boil the Lake completeness principle, and scope mode system are adapted from gstack's plan-ceo-review skill.
  • Council of High Intelligence — 0xNyk's 18-thinker multi-persona deliberation skill. The think-tank-dialectic skill's enforcement mechanisms (Dissent Quota, Counterfactual Trigger at >70%, Problem Restate Gate, Minority Report as first-class verdict section, Epistemic Diversity Scorecard) are adapted from Council's 7-step protocol and agent frontmatter conventions. The key meta-insight — every thinking style must carry its own fail-safe — comes from observing that 100% of Council's 18 agents have a Grounding Protocol section with self-constraining hard rules.
  • Agora — Professor Li's 6-room, 31-thinker extension of Council. The think-tank-dialectic skill's Hegelian Arc structure (Thesis → Antithesis → Synthesis with forced non-compromise synthesis proposal), Adaptive Depth Gate, Tacit Knowledge Extraction protocol (Polanyi), and "different tool, not better tool" framing are adapted from Agora's 8-step deliberation protocol and the /forge engineering room's verdict template.
  • my-claude-devteam — NYCU-Chung's 12-agent + 15-hook engineering team plugin for Claude Code. The v2.4.0 methodology agents (reviewer / debugger / planner) absorb the Three Red Lines discipline (closure / fact-driven / exhaustiveness), six-element Task Prompt contract, evidence-first debug methodology, PUA stress-mode trigger, and physical tool-restriction pattern (read-only methodology agents) from devteam's P7/P9/P10 framework. The v2.5.0 hooks layer absorbs 14 of devteam's 15 hooks (8 default-on Tier A + 6 opt-in Tier B) with Ship A review adjustments: anchored branch-protection regex (C1 fix), unified secret-patterns module (mi1 fix), cost-tracker opt-out, and 8/8 Tier A testing coverage. The layered split — autopilot owns methodology, voltagent owns role specialization — is a deliberate divergence from devteam's all-in-one approach to stay orthogonal to the voltagent role-agent ecosystem.
  • claude-powerloop-plugin — Aotokitsuruya's cron-loop Plan/Execute/Review/Sample plugin for Claude Code (Apache-2.0). The references/blind-dispatch.md outcome-blinding principle (round-2+ reviewer re-dispatch must strip prior verdicts to prevent quality-gate self-bypass) and the leaky-vs-blind prompt example pair are adapted from powerloop's skills/powerloop/examples/blind-dispatch.md. powerloop applies the discipline in a multi-session cron loop; autopilot scopes it to session-driven re-dispatch under quality-pipeline Re-review Loop and audit Phase 4 verification.

Development

To contribute or customize skills locally:

# 1. Install once via the normal flow (required)
/plugin marketplace add cookys/autopilot
/plugin install autopilot@autopilot

# 2. Clone and switch to dev mode
git clone git@github.com:cookys/autopilot.git ~/projects/autopilot
cd ~/projects/autopilot
./scripts/dev-setup.sh

Dev mode symlinks the plugin cache to your local clone. Edits to skills/ take effect immediately after /reload-plugins — no reinstall needed.

Push/pull works normally across machines. Each machine runs step 1 once, then dev-setup.sh once.

Note: Dev mode sets version: "dev" in the plugin registry. To revert to the release version, run /plugin update autopilot@autopilot.

Cache directory layout

The plugin cache lives at ~/.claude/plugins/cache/autopilot/autopilot/. Each entry is either a versioned directory (snapshot from install/update) or a symlink to a local clone:

~/.claude/plugins/cache/autopilot/autopilot/
├── develop -> ~/projects/autopilot   # symlink — live edits, /reload-plugins to sync
└── 2.0.0                             # snapshot — created by install or reload

Symlink naming: The cache directory name does not need to be a semver string. You can use semantic names like develop, nightly, or local to distinguish dev symlinks from release snapshots. Claude Code resolves the symlink and reads plugin.json inside for the actual version.

Stale cache cleanup: After upgrading, old version directories may linger. Remove them manually:

rm -rf ~/.claude/plugins/cache/autopilot/autopilot/<old-version>

Branch workflow

BranchPurposeplugin.json version
mainStable releases, tagged (e.g. v1.4.5)Matches latest tag
developNext version developmentNext major/minor (e.g. 2.0.0)

When developing: checkout develop, symlink points to it, /reload-plugins picks up changes. Remember to bump plugin.json version before tagging a release.

Update (marketplace users)

/plugin update autopilot@autopilot

Changelog

Origin

Distilled from 100+ completed projects using AI-driven development.

License

MIT — see LICENSE for details.

Ver o original no GitHub

Bom para

Relacionados