Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

autopilot-init

/autopilot-init

Konfiguruje jednorazowo środowisko autopilota: wykrywa zainstalowane narzędzia AI, konta i poziomy modeli.

Licencja
MIT
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Konfiguruje jednorazowo środowisko autopilota: wykrywa zainstalowane narzędzia AI, konta i poziomy modeli.

Oryginalny opis (EN)

One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/au

Jak działa

  1. The policy the roster must express (README, "Tiers")
  2. Steps
  3. Adapter format (for reference)
Sekcje z nagłówków SKILL.md, w oryginale · 42 linii, 1 819 słów
Podgląd SKILL.md
---
name: autopilot-init
description: One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/autopilot-init", "set up the autopilot", "add a harness/account/model to the autopilot", or when another autopilot skill reports a missing roster.
---

# Autopilot: init

**Caveman, always.** Your first action, before any other tool call: invoke the `caveman` skill (`/caveman`), and keep it for the whole session, including after a resume or a context compaction (invoke it again then). If it is not installed, follow its rules anyway: answer first, no ceremony, commands, paths, numbers and errors verbatim. Every subagent you start talks caveman too: `run-model` adds the rule to every model prompt by itself, and every Agent-tool (subagent) prompt you write starts with "Invoke the `caveman` skill first and answer terse." Persisted text stays plain prose: code, comments, docs, commits, Linear, `PLAN.md`.

Goal: a roster at `~/.config/linear-autopilot/models.json` (`$AUTOPILOT_CONFIG_DIR` overrides) where every entry has a tier (`level`), a `vendor`, a `subscription` and a passed smoke test, and a `bin/harness check` that reports nothing blocking. Nothing personal (accounts, plans, cooldowns, API keys) is ever written into the skill repo.

`bin/<x>` below means the `bin` directory next to this SKILL.md (`~/.claude/skills/autopilot-init/bin/<x>` after `install.sh`, `${CLAUDE_PLUGIN_ROOT}/skills/autopilot-init/bin/<x>` as a plugin).

## The policy the roster must express (README, "Tiers")

1. **Every role has its tier.** Tier 1 (flagship) plans, pre-mortems, reviews milestones and coordinates; Tier 2 (balanced) implements, fixes and reviews each round of ticket code (implementer and reviewer always two different models; owner, 2026-11-11); Tier 3 (fast and cheap) implements only when a project pins it (models.json or the project's tier table); Tier 4 (every Mistral model, every free model, old Gemini) only does trivial tasks; Tier 0 (frontier ceiling) is never used unless the owner asks for one run. The tier comes from the owner's tier table (`bin/autopilot_lib.py` `DEFAULT_TIER_TABLE`, overrides in `models.json` `tier_table`): never ask the owner what the table already answers. Ask only about a model the table does not know.
2. **Vendor -> CLI.** Anthropic models only through `claude`, OpenAI only through `codex`, Google only through `agy`, Mistral only through `vibe`, xAI through `grok` or `cursor`, every other vendor through `opencode` (OpenCode Go or OpenRouter). `bin/harness add-model` refuses anything else; never work around it (no Claude through Antigravity or OpenRouter, no GPT through Cursor).
3. **No hand-ordered pools.** A role takes every model of its tier. At run time `run-model` draws one at random, weighted by the credit left on its account and by its subscription (paid first, free plans last), so every paid subscription is used up before its reset. Never encode preferences by hand.
4. **The coordinator's account is protected, and detected, not configured.** Whatever CLI and account the coordinator session runs on is the protected one: Claude Code is recognised by `CLAUDECODE` and its account by the session's `CLAUDE_CONFIG_DIR` (the default home when unset); another CLI by its adapter's `coordinator_env` and `account_env`; `AUTOPILOT_COORDINATOR=<cli>[/<account>]` forces it. Its models run last, for cheap roles only, and only while it keeps `coordinator_reserve` (default 30% of the 5-hour window and 20% of the weekly window). Another login of the same CLI is a normal account. Starting the coordinator from another account moves the protection there by itself.
5. **Implementer and reviewer are always different models.** Enforced at run time (fail closed). Accounts of the same model are the same reviewer; a reviewer of another vendor than the implementer is preferred when one is available.
6. **Subscriptions and free tiers only.** No paid per-token ids, no top-ups, no extra-usage credits.
7. **No speed variants.** Never add a `-fast` / `build-fast` / "Fast" variant of a model family (e.g. `grok-4.7-build-fast`), whatever its tier: more expensive, no quality gain. `bin/harness add-model` refuses it, `bin/harness init` drops it, `run-model discover` skips it; only the owner can override with an explicit `--allow-fast` (never pass it on your own). "Flash" / "Flash-Lite" (Gemini, DeepSeek, GLM) are model families, not speed variants: add them normally.

## Steps

1. **Create or import the roster.**
   - New machine: `bin/harness init` (copies `templates/models.json`: example models of November 2026 with their tier and vendor, no subscription).
   - Existing roster in the format before the tier policy (it has `pools`): `bin/harness migrate --dry-run`, show the user what changes, then `bin/harness migrate`.
   - Existing private roster to import: `bin/harness init --import <path/to/models.json>`.
2. **Discover what is really installed.** `bin/harness discover`: one line per CLI: installed (a real executable on PATH; a shell alias or function wrapping a removed binary counts as NOT INSTALLED, because `run-model` runs the binary, not the user's shell), adapter present or `NO ADAPTER`, version, roster entries; then one line per account directory on disk (e.g. `~/.codex*`) with whether it holds a login, who it is (email, plan, from the login's token claims; tokens are never printed), and the `add-account` command when it is not in the roster. A directory without a login is not an account. For a CLI that is not installed but has roster entries, tell the user now (install it, or `bin/harness set <key> excluded "not installed"`): finding out at run time costs a night.
3. **Register a CLI the runtime does not know** (rare: under rule 2 a new CLI only serves vendors without a CLI of their own). Ask the user (or read its `--help`) for the non-interactive invocation with full permissions, the model flag, stdout or an output-file flag, the variable that selects another account, a model-listing command, a usage command, and a variable the CLI sets in the processes it starts. Then `bin/harness new <name> --binary <bin> --vendor <vendor|by_model> --argv '["-p","{prompt}","--model","{model}","--yes"]' [--output file] [--account-env VAR --account-default ~/.x] [--coordinator-env VAR] [--list-cmd ...] [--usage-cmd ... --usage-regex ... --usage-groups ...] [--tokens-kind ... --tokens-path ...]`. Check it with `bin/harness adapters`.
4. **Add accounts: one standard for every harness.** The default account lives in the CLI's own home (`~/.codex`, `~/.claude`, `~/.local/share` for opencode); the next accounts live in `<default>-b`, `<default>-c`, ... and their roster keys are `<key>-b`, `<key>-c`, ... `bin/harness add-account <cli> b [--label "who@example.com"]` clones every base model of that CLI with the account's home. The user logs in once in that home. A directory with another name is renamed to the standard (`bin/harness set-home` when it was already in the roster), never registered as is.
5. **Add models.** For each model the user wants that is not in the template: `bin/harness add-model <key> --cli <cli> --model <id> [--family 'gpt-*-sol']`. The tier comes from the tier table, the vendor from the id; `--level` only for a model the table does not know (ask the owner which tier, with the README table in front of them). Give versioned ids a `family` with a `*` so `run-model discover` keeps them on the latest version. Remove template models the user does not have (`bin/harness remove <key>`).
6. **Ask once about subscriptions and plan sizes, per account.** For each paid account also record its plan's relative size as `capacity` in models.json (1 = the smallest plan; e.g. 12 for a plan with 12x its usage): draws are weighted by the remaining total usage of each subscription, credit left times capacity. Show the accounts (`bin/harness list`) and ask in one message, for each `<cli>/<account>`: paid (and the plan name), free plan, or reserved for other uses (and why). Record each answer: `bin/harness subscription <cli> <account|default> paid --plan "<plan>"`, `... free`, `... reserved --reason "<their words>"`. Reserved accounts are never used anywhere. An account the owner only wants kept out of one project goes in that project's `state.json` `exclude` instead (asked by `/autopilot-run` setup). Free models stay free whatever their account's plan.
7. **Detect the coordinator account.** `bin/harness whoami` prints the CLI and account this session runs on and the roster keys on it. Tell the user those keys are last resort for cheap roles only, guarded by `coordinator_reserve`. Nothing about it is written in `models.json`: each project records the account it was started from (`run-model whoami --record`) and re-detects it on resume.
8. **Smoke test every model** that is not excluded: `bin/run-model smoke <key>` (a 120 s "reply AUTOPILOT_OK" run; the coordinator's own account last, or skipped when the user wants to spare it). A model that fails is cooled down; fix the adapter or the login, `bin/run-model reset <key>`, smoke again, or remove it.
9. **Read the quotas and the latest versions.** `bin/run-model usage --apply` (every account's windows, used percentage and reset time; cools what is exhausted; records the credit left that weights the draws) and `bin/run-model discover --apply` (newer ids of every family, smoke-tested before switching). Harnesses without a usage probe say so: the runtime learns their resets from quota errors.
10. **Check the result.** `bin/harness check` prints, per role, the candidate models with tier, vendor, account, subscription, health and credit left, then every missing piece with what to do: a role with no candidate (e.g. no Tier 2 model: no ticket can be reviewed), a review role with a single vendor (works, but an outage of that vendor stops every review), no Tier 1 model of another vendor than the coordinator (no pre-mortem, no plan review), a CLI not installed, a refused entry, an unknown subscription, a coordinator account not detected. Fix what blocks; show the user the rest. Exit 0 means nothing blocks.
11. **Linear access.** Check that this harness has Linear tools (MCP), else that `LINEAR_API_KEY` is set and `bin/linear teams` answers.
12. **Permissions, so the run never stops on a prompt.** Show the user the rules in `templates/permissions.json`, plus any project command they already know their checks need. With their approval, merge them into `~/.claude/settings.json` under `permissions.allow` through the harness's settings mechanism (Claude Code: the `update-config` skill), never replacing existing entries. Rules use the prefix form `Bash(<command> *)`; replace `{HOME}` with the user's home. Never pre-approve actions that need a per-use owner decision: publishing a website, merging to the default branch, opening a PR, deleting branches or worktrees, paying for credits.
13. **Summary for the user:** the `bin/harness check` table (role -> candidates), the subscriptions recorded, the coordinator account detected, what was removed or excluded and why, the quotas right now, the missing pieces, and that `/autopilot-plan` is the next step.

## Adapter format (for reference)

`harnesses/<cli>.json`: `name`, `binary`, `vendor` (or `by_model` to derive it from the model id), `run.argv` with `{prompt}`, `{model}`, `{out}`, `{cwd}` placeholders, `run.env`, `run.output` (`stdout` or `file`), `account_env` / `account_default` / `account_detect`, `account_login` (the file that proves a login, and optional JWT claims naming the account), `coordinator_env` (variables the CLI sets in the processes it starts, so a coordinator session running in it is detected; only Claude Code's `CLAUDECODE` is declared today), `list_models` (`command` + `regex`, `json_file`, `probe` for a CLI without a listing: next version ids are smoke-tested, or `none`), `usage` (`command` + `regex` + `groups`, `codex_sessions`, or `none`), `quota_patterns`, `waiting_patterns` (optional: the CLI's own input prompts; by default only a non-code last line after 30 s of silence counts), `tokens` (`kind` + `path`: the local log `bin/tokens` counts consumption from). The repo's `harnesses/` has one per known CLI; copy the closest one as a starting point. Cursor: `cursor-agent` has one login per machine; `auto` is not a model id, and under the vendor -> CLI rule only xAI models go through it.
Pliki w paczce (2)
  • SKILL.md 13 KB
  • bin 1 KB

Wersje

W bazie nie ma innych skilli o nazwie autopilot-init.

Migawka bazy z 13.11.2026 · wersja paczki 1a528bba15df (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100autopilot-setup
    Prowadzi przez kreator ról, modeli, poziomu wysiłku i planu subskrypcji Autopilota i zapisuje profil.
  • 100autopilot-plan
    Zamienia dużą zmianę w plan autopilota z SPEC.md i tasks.json, który wykonuje się bez nadzoru w wielu sesjach.
  • 100autopilot-run
    Wykonuje zaplanowany projekt Linear przez długą sesję bez nadzoru, zgłoszenie po zgłoszeniu, z jednym commitem na zgłoszenie.
  • 100autopilot-codex
    Obsługuje pełnozamknięty runtime autopilota w Codex: polecenie /autopilot, zatwierdzanie projektu, red-blue, pięciowarstwowe QA i kontynuację metodologii autopilota.
  • 100autopilot-codex
    Obsługuje pełnozamknięty runtime autopilota w Codex dla tego repozytorium: /autopilot, red-blue, zatwierdzanie projektu i pięciowarstwowe QA, bez operowania na plikach runtime wtyczki Claude Code.
  • 100open-pr
    Otwiera pull request gotowy do recenzji i prowadzi autopilota oraz pętlę przeglądu kodu, aż wynik będzie zaliczony.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.