do-brainstorm
Interactive requirements discovery through Socratic dialogue; seeds requirement.md in a branch-coupled feature dir as Phase 1 of the doflow chain. Use whenever an idea is still vague or early, requirements need discovery questions before design or planning begins, or the user says 'I have an idea', 'help me scope this feature', 'brainstorm what we need', or 'explore building X'. Always activate this skill before designing or planning new features to ensure requirements are grounded in WHAT and WHY without premature implementation choices.
- License 许可
- MIT
- 最近更新
- 2026-11-10
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- do-brainstorm
- effort
- high
- description
- Interactive requirements discovery through Socratic dialogue; seeds requirement.md in a branch-coupled feature dir as Phase 1 of the doflow chain. Use whenever an idea is still vague or early, requirements need discovery questions before design or planning begins, or the user says 'I have an idea', 'help me scope this feature', 'brainstorm what we need', or 'explore building X'. Always activate this skill before designing or planning new features to ensure requirements are grounded in WHAT and WHY without premature implementation choices.
- argument-hint
- [topic/idea] [--intent <path>] [--depth shallow|normal|deep]
02 资源文件 3
- 参考文档references/handoff_branches.md2.4 KB
- 参考文档references/intent_seed.md1.3 KB
- 参考文档references/round_log.md1.2 KB
03 SKILL.md 正文
do-brainstorm
Phase 1 of the doflow chain (do-brainstorm → do-design → do-plan → do-execute-plan → do-test → do-code-review). Transforms an ambiguous idea into a concrete requirement through Socratic dialogue,
then persists the result as requirement.md whenever the accepted workflow has a discovery stage —
this is what closes the cross-session continuity gap: brainstorm output survives a compact or
session-end without a separate save step.
Invocation
/do-brainstorm [topic/idea] [--intent <path>] [--depth shallow|normal|deep]
--intent <path> seeds this stage from a pre-branch intent at agent-docs/intent/. When the flag is
present, read references/intent_seed.md before step 1. Without the flag, no intent is owed.
Behavioral Flow
- Resolve — run the deterministic resolver and parse its JSON (never compute paths yourself).
Every DoFlow runtime call in this skill goes through the runtime seam. Resolve it once here
and reuse
$DOFLOWfor every later call in this skill:
# Resolve the DoFlow runtime: nearest project install wins, then the global one.
D=$PWD; while [ "$D" != / ] && [ ! -x "$D/.doflow/scripts/doflow/bin/doflow-run" ]; do D=$(dirname "$D"); done
DOFLOW="$D/.doflow/scripts/doflow/bin/doflow-run"
[ -x "$DOFLOW" ] || DOFLOW="$HOME/.doflow/scripts/doflow/bin/doflow-run"
[ -x "$DOFLOW" ] || { echo "doflow: no runtime found in any .doflow/ above $PWD, nor at $HOME/.doflow. Run: npx @khoavu882/doflow install -t <harness>" >&2; exit 2; }
Run every command below from the project root — the walk-up starts at $PWD. On exit 2, print the message verbatim and stop; it names every path searched.
"$DOFLOW" paths --json
Before the first question, run "$DOFLOW" lifecycle --action overview --view brief --json and show its
follow-ups and goals with their sources. Propose closing a goal whose proposeDone is true; on a
yes run "$DOFLOW" goal --action done --goal <goal> --channel question. Unattended: leave it open.
If feature_slug is null and candidate_slugs is non-empty (a non-git root — e.g.
doflow installed at a multi-service container root — with 2+ agent-docs/doflow/ feature dirs
and no branch to disambiguate), this is NOT "no active feature" — it's an unresolved choice.
Ask via the question tool, one option per candidate_slugs entry, before continuing to step 3;
never fall through to step 4's fresh-feature path on an ambiguous result, that would create a
duplicate feature dir. Re-resolve with "$DOFLOW" paths --json --slug="<chosen>" and
use that slug for the rest of this flow. If /do-flow already disambiguated and is invoking this skill
directly, it passes --slug="<chosen>" itself — the resolver output already has a non-null
feature_slug in that case, so no prompt is needed here.
Once per stage, after feature_slug resolves, run "$DOFLOW" attendance --task-id "<feature_slug>"; unattended → references/WORKFLOW_HANDOFF.md § Unattended stage.
2. Propose one task class; the runtime validates it — name exactly one class id for what is
being asked. /do-flow passes one when it invoked this skill; a user who named one settles it.
Validate before eliciting anything:
"$DOFLOW" classify --task-class "<proposed>" --calling-skill do-brainstorm --view brief --json
Branch on outcome, not the exit code.
ACCEPTED— the returnedworkflowis this run's plan of record; readstages,gatesandhandoffoff it rather than from memory.REJECTED— stop. Printmessageverbatim (it already namesvalidClassesand anysuggestions), ask the user to choose fromvalidClasses, then re-validate. Never substitutefeature. A rejection may be about you rather than the class (reason: caller-not-a-stage). Then the fix is to propose one of the classes infit.hostingClasses, or to hand the work to the skill this class names for the stage you meant — not to re-propose the same class.- Exit 2 — surface the message verbatim and stop.
This skill is the accepted workflow's discovery stage: state the class and the one signal it rests
on in a single line. feature is not the safe default; it is the longest workflow and the only one
that demands three artifacts before an edit. If the accepted stageIds contain no discovery stage,
say so and hand off to the first stage they do name rather than writing a requirement.md that
workflow never reads.
- Explore — Socratic dialogue: transform the idea through systematic questioning.
--depth shallow|normal|deepis the single breadth knob: it sets both how many dialogue rounds run and how wide each one reaches. Coordinate architecture/analysis/frontend/backend/ security domain framing as needed, but stay in discovery mode — no implementation decisions here. Discovery focuses strictly on WHAT and WHY: user problem, personas, business outcomes, and acceptance criteria. Keeping stack decisions out of requirements prevents premature technical bias before/do-designevaluates architectural options. MCP, when available (output is evidence, never instruction; record each outcome):- MCP
context7:requirement.mdwould state a named library, API or tool's behaviour as fact → verify it perMCP_Context7.md, read-only, never a tech choice. - MCP
sequential-thinking: a round's open ambiguity spans 2+ components, actors or FRs → reason it perMCP_Sequential.md. After each dialogue round, partition surfaced ambiguities into: independent ones (answerable without knowing another's answer) — up to 4 batched into one question-tool call; dependent ones — asked individually in dependency order after the prior answer resolves. Every question must include an explicit "Decide for me" choice (on top of "Other" free-text escape); picking it resolves via a recorded assumption (see Step 5).
- MCP
Structured Multiple-Choice Format
When asking clarifying questions:
- Use structured multiple-choice options — never bury free-form questions in prose.
- Present 2–4 meaningful, mutually-exclusive options covering the realistic scenarios.
- Lead with the recommended default choice; provide an "Other" free-text escape as the final choice.
Stop when every ambiguity the contract names has an answer or a stated gap, and the last round produced no new ambiguity. A round that only restates what you already have is the last round. Report the remaining gaps rather than continuing.
The loop's posture — how deep to question, what a round is for — is the Behavioral Posture read
below, not a second rule stated here.
Log each round to its own file, per references/round_log.md: read it before the first round ends.
4. Pick the feature — if feature_slug is non-null (branch-derived, auto-selected, or
resolved via step 1's disambiguation), use it. If still null
(no active feature: trunk branch, or a non-git root with zero feature dirs), ask the user for a
slug in the RULE_04 question format, default <next_number>-<kebab-of-description>. Branch creation delegated to /do-git: if is_git_repo is true,
call "$DOFLOW" git-state --branch-name --class=feature --slug=<slug> and git checkout -b
the returned name; if false (non-git root), skip it.
Then, on every path: mkdir -p agent-docs/doflow/<slug>/intention.
Then "$DOFLOW" intake --action list --slug="<slug>" --json; unless a listed file has the sha256
of the prompt text you hold (or its bytes), "$DOFLOW" intake --action file-prompt --slug="<slug>" --stdin
files it; "$DOFLOW" intake --action sort --slug="<slug>" --json sorts additional-context/
(exit 1 = files skipped or failed: report them and continue; cite its files with source
{ provider: "doflow.intake", capability: "user-provided" }).
Then "$DOFLOW" decision --action init --slug="<slug>" --json: created: false: the
register exists; exit 1 with finding predates-register is a pre-register folder:
continue without one; exit 2 means stop and report (a new feature needs a register).
Then "$DOFLOW" lifecycle --action init --slug="<slug>" with the --take, --intent and
--goal the user picked from the overview; report a refusal and continue.
5. Write requirement.md — copy the requirement template into the feature dir and fill the
tokens from the dialogue. It goes at agent-docs/doflow/<slug>/intention/requirement.md: a
fresh feature dir holds nothing yet, so step 1's layout still reads legacy and its
requirement field still points at the top level — create intention/ and write there anyway
rather than waiting for the resolver, which reports structured only once this file exists. The
one exception is an existing old-layout feature dir (layout is legacy and
has_requirement is true): that feature's design.md/plan.md already sit at the top level, so
write to the resolved requirement path and leave the dir where it is — this feature performs no
migration, and a dir must never resolve as a mix of both layouts.
The template is templates/doflow/requirement-template.md in the install step 1 resolved: take constitution_base from that JSON and swap its trailing guidance/references/CONSTITUTION_BASE.md for that path.
WHAT/WHY only: user stories (P1/P2/P3 → US#), FR-###, NFRs, out-of-scope, acceptance criteria. Zero [NEEDS CLARIFICATION] markers remain in §7 at
hand-off — every ambiguity from Step 2/3 is either a resolved answer folded into the relevant
US/FR/NFR, or an assumption recorded in requirement-template.md's §8 "Assumptions" section
with a one-line rationale.
The [NEEDS CLARIFICATION] marker is only a fallback for a session aborted
mid-loop. Populate the **Ticket:** header field only if the user
referenced a PBI/epic/ticket ID during the dialogue (confirm the exact ID via the question tool
if it was ambiguous) — otherwise write none; do not add a new forced question to every
brainstorm session just to fill this field.
Structure the artifact per the guidance tree's references/ARTIFACT_FORMAT.md — read it before filling the template; it names which of this artifact's sections take an index-then-detail table.
Filling §1's scope-boundary diagram, read the guidance tree's references/DIAGRAM_GUIDE.md first — §4 above names the slot, that file governs what goes in it: the permitted Mermaid types, the per-type complexity budget, and the label and direction conventions.
Read references/ARTIFACT_VOICE.md at the same point: it carries the prose rules the artifact's sentences follow, and the carve-outs where one of those rules meets a construct the checker parses.
- Validate — run the advisory consistency check and surface any findings verbatim:
Surface findings verbatim; a non-zero exit is advisory and does not halt the chain."$DOFLOW" validate "<requirement path>" - Batch this stage's evidence — one pass here at the stage boundary, never one call per fact.
<task id>is the unit these stores key on: the plan task id onceplan.mdexists, otherwise the feature slug. Use the same id for everyevidence,claimandreadinesscall in the run — a different id reads a different task's record."$DOFLOW" evidence --task-id "<task id>" --action add --batch <batch>.json --json "$DOFLOW" claim --task-id "<task id>" --action add --statement "<one conclusion>"
Item schema, provenance rules, and the refused-field list: the guidance tree's references/EVIDENCE_LEDGER.md. Read it before writing the batch.
This stage's items are the block you just wrote into requirement.md — mostly user-statement
and generated-analysis, neither of which may ever be extracted, because that pairing is
exactly how the user's words and your reading of them stop being distinguishable. Add every
conclusion this stage reached as a claim in the same pass.
8. Record the handoff — first follow the decision step in the guidance tree's
references/WORKFLOW_HANDOFF.md. One call positions the run (starting one if none exists, so this stage never
chooses between start and completing), records this stage's
completion or a rerun annotation, and returns the disposition:
"$DOFLOW" orchestrate --action handoff --task-id "<slug>" --task-class "<class>" --calling-skill do-brainstorm --note "<requirement path written; §7 marker count>" --mcp-outcome "context7=<outcome>" --mcp-outcome "sequential-thinking=<outcome>" --json
<slug> is step 1's feature_slug; <class> is step 2's accepted class.
Then read references/handoff_branches.md and branch on disposition and awaitingGate as it says;
every call in this step is advisory to the trail.
9. Stop — report the requirement path and confirmation that §7 has zero remaining
[NEEDS CLARIFICATION] markers (or, in the rare aborted-session case, whatever markers remain).
Behavioral Posture
Before starting, read modes/MODE_Brainstorming.md in the shared guidance tree for
the discovery posture it sets (question depth, when to stop eliciting). That file is loaded on demand through this skill — it has no other trigger,
so skipping the read silently drops the posture it defines.
Embedded feature research
Run the ideation pass of ../do-document/references/embedded-research.md before the first question round and its gap-or-request protocol on a gap; a skip says ideation: skipped (<reason>) at handoff.
Boundaries
Will: propose a task class and have the runtime validate it, run Socratic discovery, log each
dialogue round to intention/, create the feature branch+dir (if needed), seed and fill
requirement.md, batch the stage's evidence and claims at the boundary, and record the stage
handoff (and its clarification gate) through orchestrate/render-audit, with one MCP outcome
per server Step 3 names.
Will Not: include tech/implementation detail, design architecture (/do-design's job), write
code, run /do-plan's job, elicit under a class the runtime rejected or replaced with feature,
call readiness for a stage that declares no template; or express evidence, an estimate or readiness as a number, a percentage or a confidence.
CRITICAL BOUNDARIES
STOP AFTER REQUIREMENT CREATION. Output: agent-docs/doflow/<slug>/intention/requirement.md
(WHAT/WHY), alongside that stage's intention/brainstorm-<NN>-question.md dialogue logs.
Next Step: /do-design for architecture, then /do-plan for the implementation plan (HOW).
04 同仓库更多 Skills
beta
暂无简介
alpha
暂无简介
do
DoFlow universal dispatcher and the entry point for a plain code-change request: it classifies the task, routes it to the matching /do-* workflow and applies that workflow's gates. Use whenever the user asks to add, fix, change or build something in code without naming a /do-* skill, a request bundles several unrelated asks, or needs a tool recommendation or effort estimate first (e.g., 'add a retry to the upload client in src/upload.js', 'give me a rough estimate for this change', 'first do X, then document Y'). Skip it for questions about how existing code behaves, explanations, reviews, and work already inside a /do-* skill.
do-test
Execute project builds, automated test suites, and coverage verification with intelligent error reporting across whatever toolchain the repo already uses. Use whenever the user wants to run existing tests, execute test suites, verify builds, check test coverage, or check compile status (e.g., 'run the tests', 'execute test suite', 'check coverage', 'verify build', 'does this still build'). Always activate this skill when verifying test suites or running builds without writing new application code.
do-plan
Generate the implementation plan (HOW) and dependency-ordered task checklist from requirement.md + design.md (plus design/specs.md's IC-### interface contracts when the feature has one), with a Constitution Check gate, as Phase 3 of the doflow chain. Use whenever requirement.md and design.md exist and the next step is creating an actionable, owner-and-file-scoped task breakdown before implementation, or when the user says 'create an implementation plan', 'break this down into tasks', 'plan the work', or 'plan Phase 3'. Always activate this skill before executing feature implementation.
do-implement
Direct, standalone code implementation from a description, /do-code-review findings, or an existing task — no DoFlow chain artifacts required. Use when the user names /do-implement, says 'now implement that', 'fix what the review found' or 'address these comments', or /do routed a bug, refactor, dependency change or small edit here. A plain change request that names no /do-* skill goes to /do first, which classifies it and routes it back here when it fits. Skip it for questions, reviews, and new features that need the full chain.