| name | autopilot-brief |
| description | Autopilot brief for a long, unattended Copilot CLI run — draft a sharp `/autopilot` objective (the goal its continuation loop drives toward until the agent calls task_complete) paired with a standing charter re-fed on an `/every` reminder so the run doesn't drift on the how. Use when starting a long autopilot or `/goal` run against a plan doc, when writing or sharpening an autopilot objective, or when keeping an unattended run from drifting over many context compactions. |
Autopilot brief
Copilot CLI autopilot (/autopilot, alias /goal) auto-continues the agent
toward a set objective, auto-handling permission and input prompts, until the
agent calls task_complete. Two things make a long unattended run fail:
- Without a sharp objective it stalls — plain autopilot hits its
continuation cap after a few turns (exact count and flag in
references/cli-autopilot.md); a
completion-detectable objective is what keeps it pushing for hours.
- The objective fixes only the what — over many context compactions the
agent drifts on the how: the worktree, the push policy, the "don't ask
me" mandate, keeping the plan updated.
This skill drafts the pair that closes both gaps: a crisp objective you feed
/autopilot, and a standing charter re-fed on an /every reminder.
Autopilot drives the goal; the reminder re-briefs the method. Use them together.
When to use
- A run long enough that context compaction will happen before the plan is
done, run unattended — where the agent forgetting the push policy or the
autonomy mandate mid-run would do real damage.
- For a short, attended task that fits in one context window, skip this and just
do the work.
How CLI autopilot works
One fact shapes the brief; enabling the objective form and the launch flags are
one-time setup you do at launch (see
references/cli-autopilot.md).
- Autopilot re-continues the agent toward the objective until it calls
task_complete, so the objective's done-condition must be observable —
otherwise the agent stops early or never stops.
Steps
0. Confirm the objective form is available
Check that /goal exists or /autopilot takes an argument. If it only toggles
on/off, the AUTOPILOT_OBJECTIVES flag is off — ask the user to enable it
and relaunch (see references/cli-autopilot.md)
before drafting, so no approved work is lost to a relaunch and the objective
isn't silently discarded.
Complete when /goal exists or /autopilot accepts an objective.
1. Draft the objective and the charter
Fill both artifacts in references/brief-template.md:
the objective (plan doc, scope, one-line outcome, and the observable
done-condition) and the charter (dev/test skills, push policy, autonomy
mandate, plan hygiene, subagents, coordination, standing grants). The plan must
carry a plain Definition of Done covering exactly this run's scope, under a
unique heading the objective and charter both point at; if it's missing, write
it (or run feature-development-loop's design gate) first.
Complete when no <SLOT> remains in either artifact, the objective's
done-condition points at the plan's scope-matched Definition of Done by its
heading, and the charter names that same heading as its stop reference.
2. Review with the user until approved
Show the user both artifacts — plus any Definition of Done you authored in step
1 — and ask for explicit approval. Fold every correction back into the text and
re-show it. The push policy and the grants are the slots users most often
adjust; confirm those specifically rather than assuming.
Complete when the user has explicitly approved the exact final wording of the
objective, the charter, and the Definition of Done (seen it and said yes, not
merely been shown a draft).
3. Persist the charter and hand off the launch lines
Write the approved charter to a durable file the run and its reminder both read —
alongside the plan (e.g. docs/<feature>-autopilot.md) so a future agent
inherits it, or a session file for a throwaway run. Then give the user the exact
lines to start the run, since toggling the mode is theirs to type, not yours:
/allow-all
/autopilot <objective>
(or /goal <objective>). Once they launch, autopilot drives the objective.
Complete when the charter file exists on disk and the user has the launch
lines with the full objective inlined.
4. Arm the drift re-brief
Install a recurring reminder that re-feeds the charter file so a compacted
context re-anchors on each tick instead of drifting. Arm it with
manage_schedule — the tool /every runs — and point it at the persisted file
rather than pasting the charter, so every tick re-reads the authoritative copy:
manage_schedule action=create interval=1h \
prompt="Re-read your autopilot charter at <charter-path>. Confirm you're still
on that course — right worktree, push policy, autonomy mandate, plan kept
updated — and correct any drift before continuing. Stop this schedule once the
objective's Definition of Done is met."
The reminder carries its own off-switch: the tick stops the schedule once the
Definition of Done is met, so it disengages on arrival rather than nagging
forever.
Complete when manage_schedule action=list shows the reminder live and its
prompt resolves the persisted charter file.
