Ce:brainstorm

View source

npx skills add marcusrbrown/systematic --skill ce:brainstorm

Brainstorm a Feature or Improvement

Note: The current year is 2026. Use this when dating requirements documents.

Brainstorming helps answer WHAT to build through collaborative dialogue. It precedes /ce:plan, which answers HOW to build it.

The durable output of this workflow is a requirements document. In other workflows this might be called a lightweight PRD or feature brief. In compound engineering, keep the workflow name brainstorm, but make the written artifact strong enough that planning does not need to invent product behavior, scope boundaries, or success criteria.

This skill does not implement code. It explores, clarifies, and documents decisions for later planning or execution.

IMPORTANT: All file references in generated documents must use repo-relative paths (e.g., src/models/user.rb), never absolute paths. Absolute paths break portability across machines, worktrees, and teammates.

Core Principles

Assess scope first - Match the amount of ceremony to the size and ambiguity of the work.
Be a thinking partner - Suggest alternatives, challenge assumptions, and explore what-ifs instead of only extracting requirements.
Resolve product decisions here - User-facing behavior, scope boundaries, and success criteria belong in this workflow. Detailed implementation belongs in planning.
Keep implementation out of the requirements doc by default - Do not include libraries, schemas, endpoints, file layouts, or code-level design unless the brainstorm itself is inherently about a technical or architectural change.
Right-size the artifact - Simple work gets a compact requirements document or brief alignment. Larger work gets a fuller document. Do not add ceremony that does not help planning.
Apply YAGNI to carrying cost, not coding effort - Prefer the simplest approach that delivers meaningful value. Avoid speculative complexity and hypothetical future-proofing, but low-cost polish or delight is worth including when its ongoing cost is small and easy to maintain.

Interaction Rules

Ask one question at a time - Do not batch several unrelated questions into one message.
Prefer single-select multiple choice - Use single-select when choosing one direction, one priority, or one next step.
Use multi-select rarely and intentionally - Use it only for compatible sets such as goals, constraints, non-goals, or success criteria that can all coexist. If prioritization matters, follow up by asking which selected item is primary.
Use the platform’s question tool when available - When asking the user a question, prefer the platform’s blocking question tool if one exists (question in OpenCode, request_user_input in Codex, ask_user in Gemini). Otherwise, present numbered options in chat and wait for the user’s reply before proceeding.

Output Guidance

Keep outputs concise - Prefer short sections, brief bullets, and only enough detail to support the next decision.
Use repo-relative paths - When referencing files, use paths relative to the repo root (e.g., src/models/user.rb), never absolute paths. Absolute paths make documents non-portable across machines and teammates.

Feature Description

<feature_description> #$ARGUMENTS </feature_description>

If the feature description above is empty, ask the user: “What would you like to explore? Please describe the feature, problem, or improvement you’re thinking about.”

Do not proceed until you have a feature description from the user.

Execution Flow

Phase 0: Resume, Assess, and Route

0.1 Resume Existing Work When Appropriate

If the user references an existing brainstorm topic or document, or there is an obvious recent matching *-requirements.md file in docs/brainstorms/:

Read the document
Confirm with the user before resuming: “Found an existing requirements doc for [topic]. Should I continue from this, or start fresh?”
If resuming, summarize the current state briefly, continue from its existing decisions and outstanding questions, and update the existing document instead of creating a duplicate

0.1b Classify Task Domain

Before proceeding to Phase 0.2, classify whether this is a software task. The key question is: does the task involve building, modifying, or architecting software? — not whether the task mentions software topics.

Software (continue to Phase 0.2) — the task references code, repositories, APIs, databases, or asks to build/modify/debug/deploy software.

Non-software brainstorming (route to universal brainstorming) — BOTH conditions must be true:

None of the software signals above are present
The task describes something the user wants to explore, decide, or think through in a non-software domain

Neither (respond directly, skip all brainstorming phases) — the input is a quick-help request, error message, factual question, or single-step task that doesn’t need a brainstorm.

If non-software brainstorming is detected: Read references/universal-brainstorming.md and use those facilitation principles to brainstorm with the user naturally. Do not follow the software brainstorming phases below.

0.2 Assess Whether Brainstorming Is Needed

Clear requirements indicators:

Specific acceptance criteria provided
Referenced existing patterns to follow
Described exact expected behavior
Constrained, well-defined scope

If requirements are already clear: Keep the interaction brief. Confirm understanding and present concise next-step options rather than forcing a long brainstorm. Only write a short requirements document when a durable handoff to planning or later review would be valuable. Skip Phase 1.1 and 1.2 entirely — go straight to Phase 1.3 or Phase 3.

0.3 Assess Scope

Use the feature description plus a light repo scan to classify the work:

Lightweight - small, well-bounded, low ambiguity
Standard - normal feature or bounded refactor with some decisions to make
Deep - cross-cutting, strategic, or highly ambiguous

If the scope is unclear, ask one targeted question to disambiguate and then proceed.

Phase 1: Understand the Idea

1.1 Existing Context Scan

Scan the repo before substantive brainstorming. Match depth to scope:

Lightweight — Search for the topic, check if something similar already exists, and move on.

Standard and Deep — Two passes:

Constraint Check — Check project instruction files (AGENTS.md, and AGENTS.md only if retained as compatibility context) for workflow, product, or scope constraints that affect the brainstorm. If these add nothing, move on.

Topic Scan — Search for relevant terms. Read the most relevant existing artifact if one exists (brainstorm, plan, spec, skill, feature doc). Skim adjacent examples covering similar behavior.

If nothing obvious appears after a short scan, say so and continue. Two rules govern technical depth during the scan:

Verify before claiming — When the brainstorm touches checkable infrastructure (database tables, routes, config files, dependencies, model definitions), read the relevant source files to confirm what actually exists. Any claim that something is absent — a missing table, an endpoint that doesn’t exist, a dependency not in the Gemfile, a config option with no current support — must be verified against the codebase first; if not verified, label it as an unverified assumption. This applies to every brainstorm regardless of topic.
Defer design decisions to planning — Implementation details like schemas, migration strategies, endpoint structure, or deployment topology belong in planning, not here — unless the brainstorm is itself about a technical or architectural decision, in which case those details are the subject of the brainstorm and should be explored.

Slack context (opt-in, Standard and Deep only) — never auto-dispatch. Route by condition:

Tools available + user asked: Dispatch systematic:research:slack-researcher with a brief summary of the brainstorm topic alongside Phase 1.1 work. Incorporate findings into constraint and context awareness.
Tools available + user didn’t ask: Note in output: “Slack tools detected. Ask me to search Slack for organizational context at any point, or include it in your next prompt.”
No tools + user asked: Note in output: “Slack context was requested but no Slack tools are available. Install and authenticate the Slack plugin to enable organizational context search.”

1.2 Product Pressure Test

Before generating approaches, challenge the request to catch misframing. Match depth to scope:

Lightweight:

Is this solving the real user problem?
Are we duplicating something that already covers this?
Is there a clearly better framing with near-zero extra cost?

Standard:

Is this the right problem, or a proxy for a more important one?
What user or business outcome actually matters here?
What happens if we do nothing?
Is there a nearby framing that creates more user value without more carrying cost? If so, what complexity does it add?
Given the current project state, user goal, and constraints, what is the single highest-leverage move right now: the request as framed, a reframing, one adjacent addition, a simplification, or doing nothing?
Favor moves that compound value, reduce future carrying cost, or make the product meaningfully more useful or compelling
Use the result to sharpen the conversation, not to bulldoze the user’s intent

Deep — Standard questions plus:

What durable capability should this create in 6-12 months?
Does this move the product toward that, or is it only a local patch?

1.3 Collaborative Dialogue

Follow the Interaction Rules above. Use the platform’s blocking question tool when available.

Guidelines:

Ask what the user is already thinking before offering your own ideas. This surfaces hidden context and prevents fixation on AI-generated framings.
Start broad (problem, users, value) then narrow (constraints, exclusions, edge cases)
Clarify the problem frame, validate assumptions, and ask about success criteria
Make requirements concrete enough that planning will not need to invent behavior
Surface dependencies or prerequisites only when they materially affect scope
Resolve product decisions here; leave technical implementation choices for planning
Bring ideas, alternatives, and challenges instead of only interviewing

Exit condition: Continue until the idea is clear OR the user explicitly wants to proceed.

Phase 2: Explore Approaches

If multiple plausible directions remain, propose 2-3 concrete approaches based on research and conversation. Otherwise state the recommended direction directly.

Use at least one non-obvious angle — inversion (what if we did the opposite?), constraint removal (what if X weren’t a limitation?), or analogy from how another domain solves this. The first approaches that come to mind are usually variations on the same axis.

Present approaches first, then evaluate. Let the user see all options before hearing which one is recommended — leading with a recommendation before the user has seen alternatives anchors the conversation prematurely.

When useful, include one deliberately higher-upside alternative:

Identify what adjacent addition or reframing would most increase usefulness, compounding value, or durability without disproportionate carrying cost. Present it as a challenger option alongside the baseline, not as the default. Omit it when the work is already obviously over-scoped or the baseline request is clearly the right move.

For each approach, provide:

Brief description (2-3 sentences)
Pros and cons
Key risks or unknowns
When it’s best suited

After presenting all approaches, state your recommendation and explain why. Prefer simpler solutions when added complexity creates real carrying cost, but do not reject low-cost, high-value polish just because it is not strictly necessary.

If one approach is clearly best and alternatives are not meaningful, skip the menu and state the recommendation directly.

If relevant, call out whether the choice is:

Reuse an existing pattern
Extend an existing capability
Build something net new

Phase 2.5: Synthesis Summary

STOP. Before composing the synthesis, read references/synthesis-summary.md. The two-stage shape (internal three-bucket draft → chat-time scoping synthesis), the Path A / Path B gate, the four scoping synthesis sections with their keep tests, the tier-aware bullet budget with re-cut rule, anti-pattern guidance, soft-cut behavior, self-redirect support, and headless-mode routing all live there. Composing a synthesis without these rules loaded reliably produces malformed output — pasting the full internal three-bucket draft verbatim into chat, implementation-detail leakage into the scoping synthesis, the proposal-pitch anti-pattern. Each scoping synthesis bullet must pass the affirmability test (can the user evaluate this without reading code?) AND the detail test (1–2 lines max, conversational not documentary); over-share and over-detail are the failure modes to avoid. This is not optional supplementary reading; it is the source of truth for how the phase behaves.

Surface a scoping synthesis to the user before Phase 3 writes the requirements doc — the user’s last opportunity to correct scope before the artifact lands. Phase 2.5 is the only scope gate in this workflow. The scoping synthesis is shaped like what two product collaborators would confirm before writing a PRD, not like a comprehensive audit or a one-line preview.

Fires for all tiers including Lightweight. Skip Phase 2.5 entirely on the Phase 0.1b non-software (universal-brainstorming) route.

Path A vs Path B: the scoping synthesis shape depends on TWO signals — whether any blocking question fired AND what tier Phase 0.3 classified the scope as.

Path A — no blocking questions fired AND tier is Lightweight: announce-mode. Emit “What we’re building” prose only (1–3 sentences), then proceed to Phase 3 doc-write in the same turn. No other sections, no confirmation question. Do NOT end the turn waiting for acknowledgment. The user can revise after the doc lands if the shape is wrong — Lightweight Path A docs are short, post-hoc revision is cheap.
Path B — at least one blocking question fired, OR tier is Standard / Deep-feature / Deep-product: full tier-aware scoping synthesis with confirmation gate. Two scenarios fire Path B: (a) the user invested answer-time during dialogue, or (b) the user pre-loaded substantive scope content (Phase 0.2 fast-path with a richly-specified opening prompt). Either way, the substance earns a real checkpoint. Confirmation is unconditional even when zero call-outs survive the keep test.

Why the tier guard on Path A: Phase 0.2’s fast path serves two very different cases — a tight one-liner that needs no dialogue (“fix the typo on line 47”) and a richly pre-loaded brainstorm context that ALSO needs no dialogue because the user pre-stated everything. Without the tier guard, both route to Path A and the pre-loaded case gets a 1-sentence checkpoint for what may be 20+ items worth of scope. Tier-classifying Phase 0.3 distinguishes the two — pre-loaded substance makes the tier Standard or Deep, which then routes to Path B.

Phase 3: Capture the Requirements

Write or update a requirements document only when the conversation produced durable decisions worth preserving. Read references/requirements-capture.md for the document template, formatting rules, visual aid guidance, and completeness checks. Read references/brainstorm-sections.md for metadata field contracts and ID conventions. Read references/markdown-rendering.md for markdown presentation principles.

For Lightweight brainstorms, keep the document compact. Skip document creation when the user only needs brief alignment and no durable decisions need to be preserved.

Phase 3.5: Document Review

This is a quality and format review of the written artifact — not a second scope negotiation. Scope was confirmed at Phase 2.5; Phase 3.5 checks that the written doc faithfully reflects that confirmed scope and meets quality standards. Do not re-open scope decisions here.

When a requirements document was created or updated, run the document-review skill on it before presenting handoff options. Pass the document path as the argument.

If document-review returns findings that were auto-applied, note them briefly when presenting handoff options. If residual P0/P1 findings were surfaced, mention them so the user can decide whether to address them before proceeding.

When document-review returns “Review complete”, proceed to Phase 4.

Phase 4: Handoff

Present next-step options and execute the user’s selection. Read references/handoff.md for the option logic, dispatch instructions, and closing summary format.