Brainstorm
Explore a feature idea before writing a PRD. Adaptive depth — quick for clear features, deep for complex/ambiguous ones, grill for stress-testing formed plans. Use when the user has a vague idea, wants to compare approaches, says "brainstorm", "explore", "think through", "what are my options", "grill me", "stress-test", or "challenge this".From its SKILL.md
npx -y skills add LongJohnSilver1504/claude-skills --skill brainstormAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
7.2 KB, as published. Nobody here has run it
Brainstorm
Explore a feature idea through structured questions before committing to a PRD. Three modes based on context: Quick (clear ideas), Deep (complex/ambiguous), Grill (stress-test a formed plan).
When to use: Before generate-prd. When the idea is vague, has multiple valid approaches, the user wants to think through options, or the user has a formed plan they want challenged.
Not the same as prd-clarifier: Brainstorm operates on a raw idea or pre-PRD plan with no document yet. prd-clarifier refines an existing PRD.
Complexity Signals
Count how many of these apply to the user's idea:
- User describes multiple valid implementation approaches
- Feature crosses multiple existing sub-features or domains
- User uses hedging language ("maybe", "not sure if", "could be X or Y")
- Feature involves new external integrations or API surfaces
- User asks "what do you think?" or "how would you approach this?"
- Requirement is contradictory or ambiguous even after one question
- Feature has significant cross-feature impact (touches shared infrastructure)
0-1 signals → Quick mode. 2+ signals → Deep mode.
Grill mode is triggered independently of complexity signals (see below).
Quick Mode
- Ask 3-5 targeted questions, one at a time
- After each answer, decide if the next question is still needed or if a different question is more valuable
- After the last answer, propose a single recommended approach with brief justification
- Get user sign-off
- Save
DESIGN.md - Hand off to
generate-prd
Deep Mode
- Ask 8-12 questions, one at a time, adapting based on answers
- After gathering enough context (~5 questions), ground in the codebase (required): Grep/Read the feature area the idea touches — existing components, hooks, API adapters, domain types — before proposing any approach
- Propose 2-3 alternative approaches. For each approach, cite the specific existing files/patterns it reuses or conflicts with, and discuss:
- How it fits the existing architecture
- Complexity and maintenance cost
- User experience impact
- Cross-feature implications
- Help the user pick an approach through discussion
- Save
DESIGN.md - Hand off to
generate-prd
Grill Mode (stress-test a formed plan)
Triggered when:
- User says "grill me", "stress-test", "challenge this", "poke holes"
- User arrives with a fully formed plan or design (not a vague idea)
- An existing
DESIGN.mdis present and user wants it validated
Claude's role: Devil's advocate. You are not exploring — you are challenging. Walk down each branch of the decision tree, resolving dependencies between decisions one by one.
- Ground in the codebase (required): before challenging anything, Grep/Read the feature area the plan touches, and cite the specific files/patterns the plan reuses or conflicts with
- Identify all decisions in the user's plan (architecture, UX, data flow, edge cases, trade-offs)
- For each decision, ask one challenging question at a time:
- "You chose X — why not Y?" or "What happens when Z?"
- Provide your recommended answer with each question — the user can agree, disagree, or refine
- If a question can be answered by reading the codebase, read the code instead of asking — then present what you found and whether it supports or contradicts the plan
- Adapt based on answers — if the user's reasoning is solid, move on; if it's weak, dig deeper into that branch
- After all branches are resolved, summarize what held up and what changed
- Save
DESIGN.md(stress-tested version) - Hand off to
generate-prd
Question style for Grill mode:
- Adversarial, not exploratory: "What breaks if...?" not "What about...?"
- Always include your recommendation: "I'd suggest X because... — do you agree?"
- Reference existing code when relevant: "I see the codebase does Y in
file.ts— your plan assumes Z, which contradicts this" - Resolve dependencies: if decision A affects decision B, grill A first before moving to B
Mode Escalation
Start in Quick mode by default. After the first 2 answers, re-evaluate complexity signals. If the answers reveal 2+ signals that weren't apparent from the initial idea, escalate to Deep mode and tell the user:
"This is more complex than it seemed — I'm seeing [signals]. Let me explore this more thoroughly."
Question Approach
- One question at a time. Never present a wall of questions.
- Multiple choice when possible. "Would you prefer A, B, or C?" is easier to answer than "How should this work?"
- Open-ended when needed. "What happens when the user has no reservations?" — when the answer space is too wide for choices.
- Build on previous answers. Each question should reference what the user already said.
- No leading questions. Don't embed your preferred answer in the question.
Output: DESIGN.md
Save to .claude/pipeline/{feature}/DESIGN.md:
# Design Decisions: {Feature Name}
**Date**: {date}
**Mode**: Quick / Deep / Grill
**Complexity signals**: {list of signals that applied}
## Problem
{1-2 sentence problem statement distilled from the brainstorm}
## Approach Chosen
{Description of the selected approach and why}
## Alternatives Considered
{For Deep mode: 2-3 alternatives with why they were rejected}
{For Quick mode: "Quick mode — single approach recommended"}
{For Grill mode: decisions that were challenged and either held up or changed}
## Key Decisions
1. {Decision that should carry into the PRD}
2. {Decision that should carry into the PRD}
**Existing code reused:** {Required — the specific files/patterns the chosen approach reuses or builds on, e.g. `features/stays/hooks/use-stay-detail.ts`, the `Page<T>` envelope schema. If genuinely greenfield, say so and why.}
## Open Questions
{Anything unresolved that the PRD should address, or "None"}
Done when: DESIGN.md exists at .claude/pipeline/{feature}/DESIGN.md with every section filled — including the required "Existing code reused" line.
Transition
After saving DESIGN.md, present the next step using AskUserQuestion:
- Generate PRD — continue to
generate-prd(natural next step) - Brainstorm more — revisit or explore a different aspect
- Stop here — design doc is enough for now
- Something else
When handing off to generate-prd, mention that DESIGN.md exists so the PRD skill can read it for context.
Rules
- Never jump to implementation or code during brainstorm — this is a thinking phase
- Never write a PRD during brainstorm — that's
generate-prd's job - If the user says "just build it" or "skip brainstorm", respect that and hand off to
generate-prdimmediately - Create the
.claude/pipeline/{feature}/directory if it doesn't exist - If a
DESIGN.mdalready exists, read it and ask if the user wants to revise or start fresh