Agent skill

Flow Next Capture

by gmickel in gmickel/flow-next

Save the current conversation as a source-tagged flow-next spec, then offer review or editing.

MITAuto-check: notes

Install Flow Next Capture

skills CLI
$ npx skills add gmickel/flow-next --skill flow-next-capture -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install gmickel/flow-next flow-next-capture --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/gmickel/flow-next.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/flow-next/codex/skills/flow-next-capture .claude/skills/flow-next-capture && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
flow-next-capture
GitHub stars
709
Token cost
~1.9k tokens
SKILL.md length
777 words
Files
22 (incl. references)
Skills in repo
43
Repo updated
First seen
Licence
MIT

At a glance

Save the current conversation as a source-tagged flow-next spec, then offer review or editing.

  • Asked to capture this as a spec
  • SKILL.md covers Preamble, Mode Detection, Questions (interactive only) and Forbidden behaviors, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Flow Next Capture is an agent skill from gmickel/flow-next. Save the current conversation as a source-tagged flow-next spec, then offer review or editing. Use when asked to capture this as a spec.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 23 other files, including reference files (for example `agents/openai.yaml`, `phases.md` and `references/autofix-mode.md`).

The repository describes itself as: Faster than your agent alone. And better. A workflow plugin that takes a bug, idea or ticket to a verified pull request: specs, cross-model review by risk, live QA, receipts in… The licence is MIT.

When your agent uses it

  • Asked to capture this as a spec

Example prompts

  • “/flow-next-capture”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Read, Bash, Grep, Glob, Write, Edit, Task

What it can do on your machine

Read from SKILL.md and the folder at commit c1ce203. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Bash
    • Grep
    • Glob
    • Write
    • Edit
    • Task

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are bash).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Flow Next Capture loads about 1.9k tokens when it runs, and up to ~19k if it reads all its reference files. Until then it costs about 39 tokens; SKILL.md has 777 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~39
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~19k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Bash, Grep, Glob, Write, Edit, Task

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from gmickel/flow-next at commit c1ce203, republished under its MIT licence (© gmickel). 777 words, ~1,850 tokens.

Download SKILL.mdSave it as .claude/skills/flow-next-capture/SKILL.md (or your agent's skills folder). This skill also uses 21 other files; get the full folder from GitHub.
name
flow-next-capture
description
Save the current conversation as a source-tagged flow-next spec, then offer review or editing. Use when asked to capture this as a spec.
allowed-tools
Read, Bash, Grep, Glob, Write, Edit, Task
user-invocable
false

/flow-next:capture — agent-native conversation → spec

A discussion (or a /flow-next:prospect survivor) often holds a complete spec that never gets written down, and the next session loses it. Capture is the synthesis step: the host agent extracts the user's turns, drafts a spec against the resolved template, tags only what it paraphrased or inferred ([paraphrase] / [inferred] / [strategy:<track>]; the user's verbatim words stay untagged), writes it through flowctl, prints a compact summary, and offers the saved file in the editor (docs/read-back.md). The capture request authorizes the write; substantive choices still get short questions. No Python synthesizer, no model subprocess.

flowctl supplies thin plumbing (spec create, spec set-plan, spec set-branch, memory search) plus the chart link-spec callback after a chart-briefing capture. Capture never writes chart files or a chart's ready flag; chart never writes .flow/specs.

Clear ideas and finished chart briefings route here; capture never manufactures a chart for clear work. Unsure: /flow-next:flow --explain.

Read workflow.md for the phases and phases.md for the source tags. Branch-specific machinery lives in references/*.md, loaded only when its gate fires.

Read working-rules.md first unless you already have this run; it holds for every step of this skill.

Preamble

CRITICAL: flowctl is BUNDLED — NOT installed globally. which flowctl will fail (expected). workflow.md's Preamble defines $FLOWCTL; later blocks (there and in phases.md) use it.

Inline skill (no context: fork) — plain-text numbered prompt must stay reachable across phases; subagents cannot call plain-text numbered prompts.

Mode Detection

Parse $ARGUMENTS for the literal tokens mode:autofix and from:flow and the flags --rewrite <spec-id>, --from-compacted-ok, --yes, --override-strategy, --no-plan. Strip recognized tokens; the remainder is ignored (the conversation is the input).

bash
RAW_ARGS="$ARGUMENTS"
MODE="interactive"
REWRITE_TARGET=""
FROM_COMPACTED_OK=0
COMMIT_YES=0
OVERRIDE_STRATEGY=0

if [[ "$RAW_ARGS" == *"mode:autofix"* ]]; then
  MODE="autofix"
  RAW_ARGS="${RAW_ARGS//mode:autofix/}"
fi

if [[ "$RAW_ARGS" =~ --rewrite[[:space:]]+([^[:space:]]+) ]]; then
  REWRITE_TARGET="${BASH_REMATCH[1]}"
  RAW_ARGS="${RAW_ARGS//--rewrite ${REWRITE_TARGET}/}"
fi

if [[ "$RAW_ARGS" == *"--from-compacted-ok"* ]]; then
  FROM_COMPACTED_OK=1
  RAW_ARGS="${RAW_ARGS//--from-compacted-ok/}"
fi

# --yes (autofix write gate), --override-strategy, --no-plan and from:flow
# authorize durable writes, so they are EXACT-token matches: lookalikes
# ("--yesterday", "--no-planning", "from:flowchart") stay in the remainder.
NO_PLAN_OPT=0
FROM_FLOW=0
CLEANED_ARGS=""
for TOK in $RAW_ARGS; do
  if [ "$TOK" = "--yes" ]; then
    COMMIT_YES=1
  elif [ "$TOK" = "--override-strategy" ]; then
    OVERRIDE_STRATEGY=1
  elif [ "$TOK" = "--no-plan" ]; then
    NO_PLAN_OPT=1
  elif [ "$TOK" = "from:flow" ]; then
    FROM_FLOW=1
  else
    CLEANED_ARGS="$CLEANED_ARGS $TOK"
  fi
done
RAW_ARGS="$CLEANED_ARGS"

if [ "$MODE" = "autofix" ]; then
  echo "GATE ACTIVE — STOP. Read references/autofix-mode.md before continuing."
fi   # default branch: bare no-op — NO link, NO read path
ModeWhenBehavior
Interactive (default)User is at the terminalAsks on duplicates and must-ask cases; writes the spec, shows its summary, offers the editor; no generic write approval
Autofix (mode:autofix)Batch or scripted invocationNo questions; every ask becomes exit 2; writes only with --yes

When the sentinel prints, read references/autofix-mode.md before Phase 0; it owns the per-phase autofix rules. On the interactive path, read nothing.

Questions (interactive only)

Interactive capture follows the working rules' attended contract, plus:

Ask the user via plain text. Render the options below as a numbered list 1. … N., followed by a final option N+1. Other — type your own answer. Print the question, then the numbered list, then stop and wait for the user's next message before continuing. Parse the reply as: a bare number 1–N+1 → that option; the literal text of an option label → that option; free text after Other → custom answer.

  • Use plain-text numbered prompt (load it with ToolSearch select:plain-text numbered prompt if needed); plain-text numbered options only when the tool is unreachable. Never skip a question silently.
  • The body leads with the recommendation, a one-sentence reason, and a confidence tier ([high] / [judgment-call] / [your-call]; before asking, read references/confidence-tiers.md). Option labels stay neutral and state their consequence.
  • Plain language: one sentence of stakes, everyday words, a short gloss for any needed term (R-ID, [inferred]).
  • Never ask for facts the conversation already gave. Phase 3 asks only its must-ask cases; other [inferred] content surfaces in the summary instead.
Show full SKILL.md (268 more words)Show less

Forbidden behaviors

These protect spec trust:

  • Unstated technology. "Needs persistence" is fine; "uses PostgreSQL" needs the user to have said it. Capture writes intent; plan writes implementation.
  • Unmarked invention. An untagged line claims to be the user's words and must be findable in the evidence; every paraphrase or fill-in carries its tag, and [inferred] criteria surface in the summary for the user to keep, edit, or drop. Saving never upgrades a tag.
  • Process fences as spec content. New-vs-rewrite decisions, ready-marking, "do not implement", and the duplicate-scan outcome are capture's lifecycle, never spec body or ## Boundaries lines, and never evidence lines. Boundaries hold only product constraints a worker could get wrong.
  • Coordinates in the spec body. State contracts (types, signatures, behaviors, invariants), not code snippets, file paths, or line numbers, unless the exact location is itself the decision. Paths belong in plan's task specs.
  • Silent overwrite. Replacing a spec needs --rewrite <spec-id>; otherwise Phase 0's duplicate branch decides.
  • Acting without its own consent. Never auto-split (the user picks), never mark ready or add glossary terms without their separate questions (autofix writes neither; seeding an empty glossary is /flow-next:prime's job), never treat a saved spec as implementation consent, and never admit a draft/stale briefing silently or treat a forced draft chart briefing as final (the override names the D-IDs and reads back the risk).
  • Committing. Capture never stages or commits; the user owns when .flow/ changes land.
  • context: fork. Blocking questions must stay reachable.

Workflow

Execute workflow.md in order:

The spec at .flow/specs/<spec-id>.md is the deliverable. Autofix without --yes prints the draft summary and exits 0 with no spec allocated.

© gmickel, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 21 other files (references) in plugins/flow-next/codex/skills/flow-next-capture of gmickel/flow-next.

  • SKILL.md
  • agents/openai.yaml
  • phases.md
  • references/autofix-mode.md
  • references/business-context.md
  • references/chart-briefing.md
  • references/codebase-verification.md
  • references/compaction.md
  • references/confidence-tiers.md
  • references/duplicate-branch.md
  • references/editor-corrections.md
  • references/glossary-consent.md
  • references/glossary-terms.md
  • references/mark-ready.md
  • references/must-ask-cases.md
  • references/readiness-snapshot.md
  • references/rewrite-mode.md
  • references/split-proposal.md
  • references/strategy-alignment.md
  • … and 3 more

Open the folder on GitHubat commit c1ce203

Compare with similar skills

Flow Next Capture next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Flow Next Capture compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Flow Next Capture this skillgmickel/flow-next709—~1.9kAutomated safety check: NotesMIT
Capture Conversationoutline/outline41k—~474Automated safety check: PassCustom licence
Capturealirezarezvani/claude-skills28k1 repos~2.8kAutomated safety check: PassMIT
Modeling Conversion MetricsPostHog/posthog40k—~1.4kAutomated safety check: PassCustom licence
Context Savegarrytan/gstack136k—~9.8kAutomated safety check: NotesMIT
Cost Conversationruvnet/ruflo74k—~407Automated safety check: NotesMIT

Similar skills

  • Capture Conversation

    outline/outline

    Save the current conversation, a decision, or a set of notes as a document in an Outline collection; use when the user wants to keep what was discussed in their knowledge base.

    41k GitHub stars~474 tokensUpdated today
    Knowledge ManagementAuto-check passed
  • Capture

    alirezarezvani/claude-skills

    Captures and organizes chaotic brain dumps into a structured, actionable system with zero information loss.

    28k GitHub starsUsed in 1 repo~2.8k tokens
    Agent WorkflowsAuto-check passed
  • Official

    Build reusable conversion models — funnel/step conversion rates, drop-off, and time-to-convert — on either PostHog data-warehouse views (HogQL) or an external dbt project.

    40k GitHub stars~1.4k tokensUpdated today
    Data & AnalyticsAuto-check passed
  • Context Save

    garrytan/gstack

    Captures git state, decisions made and remaining work so that a later session can resume the task without losing context.

    136k GitHub stars~9.8k tokensUpdated today
    Agent WorkflowsAuto-check: notes
  • Cost Conversation

    ruvnet/ruflo

    Per-conversation cost view — list every session in cost-tracking with started-at, message count, top model, and total cost

    74k GitHub stars~407 tokensUpdated today
    AI & LLM EngineeringAuto-check: notes
  • Conversation Memory

    davila7/claude-code-templates

    Persistent memory systems for LLM conversations including short-term, long-term, and entity-based memory Use when: conversation memory, remember, memory persistence, long-term memory, chat history.

    33k GitHub starsUsed in 4 repos~440 tokens
    Agent WorkflowsAuto-check passed

More from gmickel/flow-next

All 43 skills in this repo
  • Flow Next Resolve PR

    gmickel/flow-next

    Resolve PR review feedback. An agent skill from gmickel/flow-next.

    709 GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Flow Next Resolve PR

    gmickel/flow-next

    Resolve PR review feedback — fetch unresolved threads, triage, dispatch per-thread resolver agents, validate, commit, reply + resolve via GraphQL.

    709 GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Flow Next

    gmickel/flow-next

    Manage .flow/ tasks and specs. An agent skill from gmickel/flow-next.

    709 GitHub stars~1.6k tokensUpdated today
    Auto-check passed
  • Flow Next Audit

    gmickel/flow-next

    Audit .flow/memory/ entries against the current codebase and decide Keep / Update / Consolidate / Replace / Delete / Harden per entry.

    709 GitHub stars~3.1k tokensUpdated today
    Auto-check: notes
  • Flow Next Chart

    gmickel/flow-next

    Decision-map discovery for one oversized unclear idea before capture.

    709 GitHub stars~2.7k tokensUpdated today
    Auto-check: notes
  • Flow Next Chart

    gmickel/flow-next

    Decision-map discovery for one oversized/unclear idea before capture.

    709 GitHub stars~2.6k tokensUpdated today
    Auto-check: notes

Questions about Flow Next Capture

What does Flow Next Capture do?

Save the current conversation as a source-tagged flow-next spec, then offer review or editing. Flow Next Capture is an agent skill from gmickel/flow-next. Save the current conversation as a source-tagged flow-next spec, then offer review or editing.

When should I use Flow Next Capture?

Flow Next Capture fits situations like: asked to capture this as a spec.

How do I install Flow Next Capture in Claude Code?

Run `npx skills add gmickel/flow-next --skill flow-next-capture -a claude-code`. Or copy the skill folder (plugins/flow-next/codex/skills/flow-next-capture in gmickel/flow-next) into .claude/skills/flow-next-capture in your project. Claude Code loads it when a task matches its description.

How do I install Flow Next Capture in Codex?

Run `npx skills add gmickel/flow-next --skill flow-next-capture -a codex`. Or copy the skill folder (plugins/flow-next/codex/skills/flow-next-capture in gmickel/flow-next) into .agents/skills/flow-next-capture in your project. Codex loads it when a task matches its description.

Can I use Flow Next Capture in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add gmickel/flow-next --skill flow-next-capture -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/flow-next-capture, .gemini/skills/flow-next-capture, .github/skills/flow-next-capture and .opencode/skills/flow-next-capture in your project.

What does Flow Next Capture need to run?

SKILL.md names no scripts, command-line tools or credentials: Flow Next Capture is instructions for the agent only. Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Bash, Grep, Glob, Write, Edit, Task.

Does Flow Next Capture access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Flow Next Capture safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Flow Next Capture use?

Flow Next Capture is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Flow Next Capture use?

About 1.9k tokens (SKILL.md is roughly 7.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 17k tokens, read only when the agent opens those files.

What are the alternatives to Flow Next Capture?

Skills that share tags, products or a category with Flow Next Capture: Capture Conversation (outline/outline, 41k stars), Capture (alirezarezvani/claude-skills, 28k stars), Modeling Conversion Metrics (PostHog/posthog, 40k stars) and Context Save (garrytan/gstack, 136k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Flow Next Capture?

gmickel (a GitHub user) maintains it in gmickel/flow-next, which has 709 GitHub stars. The repository holds 43 skills in this directory. The repository was last updated on October 10, 2026.

Source: gmickel/flow-next on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.