Every flow-next skill, grouped by where it sits in the pipeline. Use the smallest sufficient workflow. Each skill runs standalone, and the stages compose in any order the work needs. When you would rather not choose, /flow-next:flow chooses for you and runs the route; flow --explain prints the choice without running it.
The Invocation column shows the canonical form. You do not have to type it - every skill is triggered by describing what you want, and every flag has a plain-language equivalent (the cookbook shows the pairs). Say “make a spec from what we discussed” and capture runs; the command is just the precise version.
You type the command; an agent names the skill. Since 6.1.0 every /flow-next:* command on Claude Code is typed-only, so the agent’s skill listing shows each skill once instead of twice. A prompt, loop recipe, or instruction file that asks an agent to run a skill names it by id, for example flow-next:flow-next-work for /flow-next:work. On Codex the skill is $flow-next-work; on OpenCode it is /flow-next-work.
| Skill | Invocation | What it does |
|---|
| Flow | /flow-next:flow | The conductor - hand it whatever you have, it routes from the shared reference, runs the stage skills, and stops at the next decision that is yours. --explain prints the route and writes nothing. --auto [<spec-id>] drives one ready spec to a PR unattended, hop after hop, from the same reference, and records every decision it made in the PR. |
| Strategy | /flow-next:strategy | Create and maintain STRATEGY.md - the product anchor downstream skills read for grounding. |
| Prospect | /flow-next:prospect | Generate ranked candidate ideas grounded in the repo, upstream of planning. |
| Chart | /flow-next:chart | Optional decision-map discovery for one oversized unclear idea before capture - one D-ID at a time, briefing out. |
| Capture | /flow-next:capture | Synthesize a conversation into a spec with source-tagged R-IDs, then review the saved file. |
| Refine (interview) | /flow-next:refine | One question pass over the open decisions, optionally focused by a free-text scope lens, with append-only R-IDs, or --scope=research for a read-only pass that resolves unfamiliar libraries into the spec. Formerly /flow-next:interview (removed in 6.1.0). |
| Skill | Invocation | What it does |
|---|
| Plan | /flow-next:plan | Optional task decomposition, chosen on a positive signal: you asked, separate owners, or staged PRs. |
| Plan Review | /flow-next:plan-review | Carmack-level adversarial review of a spec before any work starts. |
| Deps | ask for it (“what’s blocking what”) | Show the spec dependency graph, execution order, and parallelizable phases. |
| Sync | /flow-next:sync | Manually trigger plan-sync to update downstream task specs after implementation drift. |
| Skill | Invocation | What it does |
|---|
| Work | /flow-next:work | Execute a full spec with --no-plan, or its planned tasks, with configured review and evidence gates. |
| Impl Review | /flow-next:impl-review | Carmack-level cross-model review of the implementation diff, by risk: one fix pass and one scoped re-review when you are there, a fix loop until SHIP when unattended. |
| QA | /flow-next:qa | Live-app QA pass that drives the running app and derives its scenarios from the spec. |
| Skill | Invocation | What it does |
|---|
| Make PR | /flow-next:make-pr | Close the finished spec on the branch and open a PR whose body is a reviewer’s briefing - reading order, must-read files, requirement coverage, an honest checklist. |
| Resolve PR | /flow-next:resolve-pr | Resolve PR review feedback - fetch threads, triage, dispatch resolver agents, reply + resolve. |
| Spec Completion Review | /flow-next:spec-completion-review | Verify the combined implementation of all tasks satisfies the spec requirements. |
| Skill | Invocation | What it does |
|---|
| Flow —auto | /flow-next:flow --auto | The build loop - one ready spec carried from ready to a PR in one invocation, the one unattended mode; --tick runs one hop for your host’s /loop or /goal. |
| Land | /flow-next:land <PR> | The ship loop - takes one named pull request through review threads and CI, and squash-merges it when you authorized the merge. |
| Skill | Invocation | What it does |
|---|
| Tracker Sync | /flow-next:tracker-sync | Project a spec to Linear, GitHub, GitLab, or Jira and reconcile two-way - the spec stays the source of truth. |
| Skill | Invocation | What it does |
|---|
| Setup | /flow-next:setup | Optional local install of flowctl plus CLAUDE.md / AGENTS.md instructions. |
| Prime | /flow-next:prime | Opinionated agent-readiness assessment - verdict first, ranked next-actions. |
| Audit | /flow-next:audit | Review .flow/memory/ against the current codebase - Keep / Update / Consolidate / Replace / Delete / Harden per entry. |
| Features | /flow-next:features | Seed and maintain the committed user-POV feature map - how a user reaches each feature, how an agent drives it, which traps waste a run. |
| Map | /flow-next:map | Semantic feature index of the repo (wraps clawpatch) - opt-in convenience consumed by scouts. |
| Memory Migrate | /flow-next:memory-migrate | Lift legacy flat memory files into the categorized YAML schema. |
| Skill | Invocation | What it does |
|---|
| Visual | /flow-next:visual | Restate a spec, task, diff, or the current topic as a compact markdown digest - the visual view of any spec, plan, or diff. |
| Prose | /flow-next:prose | Apply the shipped artifact prose contract to a substantial reply or draft - the same ten rules PR bodies, specs, and tracker comments already draft against. |
| Worktree Kit | dispatched on demand | Manage git worktrees for parallel feature work, isolated review, and clean workspaces. |
| Tasks & Inventory | conversational | ”Show me my tasks” - conversational access to specs and tasks in .flow/. |
| Drive | dispatched by QA | Surface-aware UI automation - picks the best available driver per surface, degrading gracefully. |
Every command that takes a spec or task id accepts either id scheme. The default form is fn-NN (/flow-next:work fn-1, /flow-next:plan fn-1.2). A spec linked to a tracker is referenced by its tracker key instead: /flow-next:work wor-17, /flow-next:plan wor-17, tasks as wor-17.1, resolution case-insensitive. See Spec and task ids.
flowchart LR
Flow["flow: route from the reference"] --> Small{"small local change?"}
Small -->|yes| Tiny["direct change, checked, handed back (no spec)"]
Small -->|no| Clear{"clear enough?"}
Strategy["strategy/prospect"] --> Clear
Clear -->|yes| Capture["capture/refine"]
Clear -->|optional chart| Chart["chart → briefing"]
Chart --> Capture
Capture -->|default: ready cohesive spec| Direct["work --no-plan"]
Direct --> Work
Capture -.->|positive plan signal| Plan["plan"]
Plan --> PlanReview["plan-review (optional)"]
PlanReview --> Work["work"]
Work --> Impl["impl-review (by risk)"]
Work -.->|"small output/wording/display fix: not reviewed, reason recorded"| Gate
Impl -->|multi-task spec| Completion["spec-completion-review"]
Impl -->|single-task spec| Gate{"pipeline.qa?"}
Completion --> Gate
Gate -->|on| QA["qa: live pass"]
Gate -->|"auto: UI-observable criteria + drivable surface + startable target"| QA
Gate -->|"off, or auto with a prerequisite missing: skipped(config: ...)"| PR["make-pr (attended: when you ask; ready unless open items)"]
QA --> PR
PR --> Stop(["run ends: the PR exists"])
Stop -.->|later, separate work| Resolve["resolve-pr"]
Stop -.->|later, land owns the merge| Land["land"]
A small local change goes direct: changed, checked, and handed back with no spec, and a PR only if you ask. Every other route carries a strong spec with R-IDs. Flow walks this graph one hop at a time and stops at the next human decision; each skill also runs on its own. Optional plan adds a task breakdown; plan-review can review the spec/design with zero tasks and checks task ordering and coverage when tasks exist. impl-review checks the resulting diff when its risk calls for review. spec-completion-review is the final gate on a multi-task spec that confirms every R-ID has evidence in the combined implementation; a single-task spec skips it unless you run it yourself. Those are the three review scopes, and they do not substitute for each other.
Most people should not start with flowctl. Slash commands are the product workflow; flowctl is the deterministic state layer those commands call.
Skills are the judgment layer; the mechanical substrate is the flowctl CLI, which every skill calls for state, receipts, and validation.