Skip to content
Skills Library
Management & product · Planning

brainstorm

/brainstorm

Refine a rough idea into a well-structured concept through Socratic questioning, targeted research and one or two fitting analysis frameworks (Six Thinking Hats, SCAMPER, Premortem), then write it to docs/brainstorms/ as the input for planning. Use when the user wants to brainstorm, explore or think through an idea, find holes in a proposal, asks "what am I missing", or wants to shape a concept before planning, whether or not the work is tracked in TaskTracker. The output feeds /create-plan, /tt-create-plan and /user-story.

Licence
MIT
Last repository change
13.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
0
HTML comments
2
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 13.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Refine a rough idea into a well-structured concept through Socratic questioning, targeted research and one or two fitting analysis frameworks (Six Thinking Hats, SCAMPER, Premortem), then write it to docs/brainstorms/ as the input for planning. Use when the user wants to brainstorm, explore or think through an idea, find holes in a proposal, asks "what am I missing", or wants to shape a concept before planning, whether or not the work is tracked in TaskTracker. The output feeds /create-plan, /tt-create-plan and /user-story.

Triggers from the description

what am I missing

Arguments

/brainstorm [idea, topic, or path to an earlier brainstorm]
Original author description

Refine a rough idea into a well-structured concept through Socratic questioning, targeted research and one or two fitting analysis frameworks (Six Thinking Hats, SCAMPER, Premortem), then write it to docs/brainstorms/ as the input for planning. Use when the user wants to brainstorm, explore or think through an idea, find holes in a proposal, asks "what am I missing", or wants to shape a concept before planning, whether or not the work is tracked in TaskTracker. The output feeds /create-plan, /tt-create-plan and /user-story.

How it works

  1. Contents
  2. How this skill runs
  3. Phase 1: Capture and classify
  4. Phase 2: Socratic clarification
  5. Phase 3: Research, when it adds something
  6. Phase 4: Focused analysis
  7. Phase 5: Write the brainstorm
  8. Before you finish
Original SKILL.md headings · 108 lines, 1,194 words
SKILL.md preview
---
name: brainstorm
description: >-
  Refine a rough idea into a well-structured concept through Socratic questioning, targeted
  research and one or two fitting analysis frameworks (Six Thinking Hats, SCAMPER, Premortem),
  then write it to docs/brainstorms/ as the input for planning. Use when the user wants to
  brainstorm, explore or think through an idea, find holes in a proposal, asks "what am I
  missing", or wants to shape a concept before planning, whether or not the work is tracked
  in TaskTracker. The output feeds /create-plan, /tt-create-plan and /user-story.
argument-hint: "[idea, topic, or path to an earlier brainstorm]"
---

# Brainstorm

<!-- contents: generated by tests/skill_structure.py --write; edit headings, not this block -->
## Contents

- [How this skill runs](#how-this-skill-runs)
- [Phase 1: Capture and classify](#phase-1-capture-and-classify)
- [Phase 2: Socratic clarification](#phase-2-socratic-clarification)
- [Phase 3: Research, when it adds something](#phase-3-research-when-it-adds-something)
- [Phase 4: Focused analysis](#phase-4-focused-analysis)
- [Phase 5: Write the brainstorm](#phase-5-write-the-brainstorm)
- [Before you finish](#before-you-finish)

Reference files (open one when a step points to it):
- `references/frameworks.md`: Analysis Frameworks
- `references/output-template.md`: Brainstorm Output Template
- `references/questioning.md`: Socratic Questioning
- `references/research.md`: Research Briefs
<!-- /contents -->

Turn a rough idea into a concept that is ready to plan, by asking good questions, bringing in the facts that matter and applying the one or two analysis frameworks that fit. The guiding rule: adapt the analysis to the idea, not the idea to the analysis. A risky migration needs a premortem, not SCAMPER; a product feature needs SCAMPER, not a risk table.

## How this skill runs

- **Inline, with the user.** It waits for answers, writes a file and offers follow-up skills, so it runs in the main conversation. Don't add `context:` or `agent:` keys to the frontmatter.
- **One session, one document.** The result is `docs/brainstorms/YYYY-MM-DD-<topic-slug>.md`. If the argument is a path to an earlier brainstorm, or one on the same topic already exists in `docs/brainstorms/`, read it and continue from its open gaps instead of starting over.
- **Start talking, not announcing.** No scripted opener. If the user has described the idea, play back your understanding and ask the first questions; if not, ask what they're thinking about.
- **Use what the conversation already holds.** If the idea, constraints or decisions were discussed before this skill was invoked, build on them and don't ask again.

## Phase 1: Capture and classify

Pin down the core concept, the stated goals, the constraints (said or implied), whether it touches an existing codebase, and the idea type. The type drives framework choice in Phase 4.

| Type | Signals |
|---|---|
| Product / feature | new capability, UX change, something users see |
| Architecture / technical | system design, refactoring, infrastructure, migration |
| Strategy / business | market, pricing, partnerships, positioning |
| Process / workflow | how work gets done, tooling, automation |
| Creative / open | vague, exploratory, "what if" |
| Risk / problem | something is broken, risky or worrying |

Two more checks:
- **Codebase context.** If the user names files, modules or features, talks about "the current system", or wants to extend something that exists, plan codebase research for Phase 3.
- **Size.** If the idea spans several problem domains, more than five or six major components or stakeholders, or a multi-month timeline, say so and agree with the user which angles this session covers. The rest become Gaps in the output, with status Needs More Exploration, ready for another session.

Play your understanding back in a few lines, then move to Phase 2.

## Phase 2: Socratic clarification

Ask in rounds of two to four questions, mixing the categories: scope, assumptions, alternatives, consequences, evidence, and occasionally whether this is the right problem at all. Question bank and pacing → `references/questioning.md`.

- Build on the previous answers rather than working through a list; ask "what" and "how" more than "why"; acknowledge a good insight before probing further.
- Hold criticism back until Phase 4. Here you are understanding, not judging.
- Keep a **parking lot**: tangents and "we could also…" ideas that aren't central. They go into the output so good ideas aren't lost.
- Ask in plain text. Open questions don't fit a multiple-choice picker.
- After each round, say what you'd still like to probe and let the user choose: keep going, or move to analysis. Continue until they are ready; there is no minimum number of rounds, and no reason to hurry them.

## Phase 3: Research, when it adds something

Research only what the brainstorm needs. Most ideas benefit from a look at external practice and prior art; purely internal ones may not. Codebase research is for ideas that touch existing code.

| Need | Agent | If that agent isn't in your agent list |
|---|---|---|
| Prior art, current practice, pitfalls, technology options | `web-search-researcher` | `general-purpose` (it has WebSearch and WebFetch) |
| Where the related code lives | `codebase-locator` | `Explore` |
| How the affected code works today | `codebase-analyzer` | `general-purpose`, briefed read-only |
| Conventions to follow for something new | `codebase-pattern-finder` | `Explore` |

When this collection is installed as a plugin, the agents are named `devflow:<name>`. Send all the research you need in one message so the agents run in parallel, and keep working with the user while they run. Ready-to-use briefs and how to fold the results in → `references/research.md`. Research informs the discussion; it doesn't replace the user's thinking, so bring the findings back as input for them to react to.

## Phase 4: Focused analysis

Pick one framework, or two when the idea clearly needs both. Running every framework on every idea produces filler.

| Idea type | Primary | Add a second when… |
|---|---|---|
| Product / feature | SCAMPER | many stakeholders → Six Thinking Hats |
| Architecture / technical | Six Thinking Hats | high risk → Premortem |
| Strategy / business | Six Thinking Hats | hard to reverse → Premortem |
| Process / workflow | SCAMPER | crosses teams → Six Thinking Hats |
| Creative / open | SCAMPER | needs direction → Six Hats (Green, Blue) |
| Risk / problem | Premortem | always → Six Hats (Black, White, Yellow) |

How to run each one, and the prompts → `references/frameworks.md`. Skip hats or letters that produce nothing for this idea. Share the main findings with the user before writing; they often correct or sharpen them.

## Phase 5: Write the brainstorm

Write `docs/brainstorms/YYYY-MM-DD-<topic-slug>.md` (create the directory if needed), or update the earlier file when continuing one. Template and section rules → `references/output-template.md`. Include only sections with real content.

Set the status honestly:
- **Ready for Planning** when the scope is clear, the key choices are made and no gap blocks a plan.
- **Needs More Exploration** otherwise, and say exactly what is missing.

Then:
1. Give the path and a summary of three to five lines: the refined idea, the decisions, the biggest risk, open gaps.
2. Offer the next step that fits: `/create-plan <file>`, or `/tt-create-plan <file>` when the project is tracked in TaskTracker; `/user-story <file>` when the user wants requirements first; another `/brainstorm <file>` session when the status is Needs More Exploration.
3. Offer `/adr` only if a real architectural or strategic decision was made during the session, such as choosing between competing approaches.

## Before you finish

- The user's answers, not your assumptions, shaped the refined idea.
- The frameworks fitted the idea type, and only useful findings were kept.
- Every risk has a mitigation and every gap a suggested next step.
- The parking lot is in the document.
- The file is written and the status matches what is actually settled.
Files in this package (5)
  • SKILL.md 8 KB
  • references/frameworks.md 3 KB
  • references/output-template.md 2 KB
  • references/questioning.md 2 KB
  • references/research.md 3 KB

Versions

RepositoryScoreLicence
This page · mhylle/claude-skills-collection90MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
vanducng/skills100MIT
Kanevry/session-orchestrator100MIT
nigelng/nng-kit100MIT
joris887/exosuit100MIT
duronext/jig100MIT
verygoodopensource/vgv-wingspan100MIT

Database snapshot: 13.11.2026 · package version d59d4acb56a0 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100bmad-brainstorm
    Facilitates structured ideation sessions using proven brainstorming techniques (SCAMPER, SWOT, 5 Whys, Mind Mapping, Six Thinking Hats, Reverse Brainstorming, Starbursting, Brainwriting). Produces a brainstorming-report.md of organized ideas and actionable insights. Operates in…
  • 100tt-create-plan
    Tasktracker-native implementation planning. Turns a /brainstorm file from docs/brainstorms/ (or a clear requirement) into a phased plan persisted as tasktracker phase tasks — NOT as a docs/plans/*.md file. Creates requirements with formal acceptance criteria, registers…
  • 100workflow-explore-idea
    Guided idea exploration workflow that develops a raw concept into a mature, PRD-ready requirement through structured Socratic interviews. Use when user wants to explore, stress-test, or develop an idea — triggers at "explore idea", "I have an idea", "let's explore", or similar.…
  • 100brainstorm-beagle
    Use when the user has a fuzzy idea and wants to shape it into a concrete project spec before planning or building. Triggers on: \"brainstorm this\", \"I have an idea for...\", \"help me think through this project\", \"what should I build\", \"spec this out\". Also catches vague…
  • 87sparring-partner
    This skill should be used whenever the user wants to develop, refine, or stress-test an idea, plan, design, research direction, product/business concept, argument, or any decision with more than one reasonable path — i.e. whenever they want a thinking partner rather than a quick…
  • 100lateral
    Lateral thinking toolkit router — when you're stuck, going in circles, need fresh ideas, or standard brainstorming keeps producing predictable results, this diagnoses the symptom and applies the right technique from the toolkit (random-stimulus, provocation, inversion,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.