agentleFS
tyler-berggrentyler-berggren/tb-claude-kit/.claude/skills/brainstorm/SKILL.md

brainstorm

Skill2 starsChanged 5 days agoMITView on GitHub

Work through an idea conversationally with Claude. All brainstorms are logged in the brain with any decisions, questions, insights, or tasks that emerge.

189 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use playtest-report, team-polish and 10 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • CoralGameSkill

    playtest-report

    Generates a structured playtest report template or analyzes existing playtest notes into a structured format. Use this to standardize playtest feedback collection and analysis.

    Also in 9 projects that use this

  • CoralGameSkill

    team-polish

    Orchestrate the polish team: coordinates performance-analyst, technical-artist, sound-designer, and qa-tester to optimize, polish, and harden a feature or area for release quality.

    Also in 11 projects that use this

  • lilangMaxSkill

    soak-test

    Generate a soak test protocol for extended play sessions. Defines what to observe, measure, and log during long play sessions to surface slow leaks, fatigue effects, and edge cases that only appear after sustained play. Primarily used in Polish and Release phases.

    Also in 6 projects that use this

  • lilangMaxSkill

    team-live-ops

    Orchestrate the live-ops team for post-launch content planning: coordinates live-ops-designer, economy-designer, analytics-engineer, community-manager, writer, and narrative-director to design and plan a season, event, or live content update.

    Also in 6 projects that use this

  • +8 more from CoralGame

The file

Show its rules and text

We split this skill into the rules it gives an agent

15 rules. 0 are common, 13 are distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 157 edited versions we read keep these.

  • 13

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before diving in, gather relevant context:

    line 48
  2. Distinctive:

    Check the brain DB for related entries (decisions, questions, insights, prior brainstorms):

    line 50
  3. Distinctive:

    Check the codebase if the topic relates to implementation.

    line 56
  4. Distinctive:

    Ask questions: Don't just answer — probe.

    line 65
  5. Distinctive:

    When the conversation reaches a natural stopping point (or the user signals done):

    line 102
  6. Distinctive:

    Update the brainstorm entry's body with a summary:

    line 104
  7. Very specific:

    Start a brainstorm session anchored to the current focus items.

    line 120
  8. Distinctive:

    Create a brainstorm entry that references the focus items:

    line 137
  9. Distinctive:

    Follow the same Steps 1, 2, 4, and 5 as New Brainstorm, with these modifications:

    line 159
  10. Distinctive:

    Attack the assumptions, not the person: Every plan rests on beliefs about the market, the user, the tech, the timeline.

    line 170
  11. Distinctive:

    Be specific about risk: Don't say "this could be risky." Say "if churn exceeds 30% in month 2, this unit economics model breaks because..." …

    line 173
  12. Distinctive:

    Steel-man before you attack: Before poking a hole, show you understand why the idea is compelling.

    line 174
  13. Distinctive:

    Every criticism carries a suggestion: Never raise a risk without proposing at least one way to address it.

    line 175
  14. Distinctive:

    Ask the user what aspect they want to revisit or continue.

    line 193
  15. Very specific:

    If .claude/kit.json has a rules."brainstorm" entry, read it and apply it as an additional instruction for this skill.

    line 230

“Common” is measured: kept by at least 6 in 10 of the 157 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Recent Brainstorms

!sqlite3 -separator ' | ' cowork/brain/BRAIN.db "SELECT '#' || e.id, e.created_at, e.title, (SELECT count(*) FROM logs c WHERE c.parent_id = e.id) || ' outputs' FROM logs e WHERE e.type = 'note' AND e.tags LIKE '%brainstorm%' ORDER BY e.created_at DESC LIMIT 5;" 2>/dev/null || echo "No brainstorms yet"

Recent Decisions & Insights (for context)

!sqlite3 -separator ' | ' cowork/brain/BRAIN.db "SELECT '#' || id, type, title FROM logs WHERE type IN ('decision','insight') AND status = 'active' ORDER BY created_at DESC LIMIT 8;" 2>/dev/null || echo "None yet"


Brainstorm

Work through an idea conversationally. Every brainstorm is logged in the brain DB as a note with brainstorm tag, and any outputs (decisions, questions, insights, tasks) are linked as children via parent_id.

Input

Optional argument: $ARGUMENTS

Dispatch:

  • focus -> start a Focus Brainstorm on the current focus items.
  • hater <topic> -> start a Hater Brainstorm — constructive skepticism to pressure-test the topic.
  • hater (no topic) -> ask the user what to pressure-test.
  • A topic or idea string -> start a New Brainstorm on that topic.
  • A bare number (e.g. 42) -> Revisit brainstorm entry #42 and continue the conversation.
  • list -> List all brainstorms with their output counts.
  • Empty -> ask the user what they'd like to brainstorm.

New Brainstorm

Step 1 — Create the brainstorm entry

Insert a note to anchor the session:

INSERT INTO logs (type, title, body, tags, importance)
VALUES ('note', '<topic title>', 'Brainstorm session started.', 'brainstorm', 5);

Note the new entry's id — all outputs from this session link back to it via parent_id.

Step 2 — Set context

Before diving in, gather relevant context:

  1. Check the brain DB for related entries (decisions, questions, insights, prior brainstorms):
    SELECT id, type, title, substr(body, 1, 200) FROM logs
    WHERE (title LIKE '%<keyword>%' OR body LIKE '%<keyword>%' OR tags LIKE '%<keyword>%')
    AND status = 'active' ORDER BY created_at DESC LIMIT 10;
  2. Check the codebase if the topic relates to implementation.
  3. Briefly present what you found — prior thinking on this topic, related decisions, open questions.

Step 3 — Brainstorm conversationally

This is a back-and-forth, not a monologue. Follow these principles:

  • Think out loud. Share reasoning, not just conclusions. Surface assumptions.
  • Be opinionated but holdable. Offer a clear perspective, but hold it loosely. Push back on weak ideas; build on strong ones.
  • Ask questions. Don't just answer — probe. "What if we..." and "Have you considered..." are more valuable than lengthy analysis.
  • Stay concrete. Tie abstract ideas to specific implementation, user scenarios, or project constraints. Reference the codebase and brain entries when relevant.
  • Diverge then converge. Early in the brainstorm, explore widely. As clarity emerges, narrow toward decisions and actions.
  • Keep it moving. Each response should advance the conversation. If you're restating the same ground, pivot or propose a decision point.

Step 4 — Capture outputs as they emerge

As the conversation produces clear outputs, log them immediately — don't wait until the end. Each output is a new entry with parent_id pointing to the brainstorm note:

Decisions:

INSERT INTO logs (type, title, body, tags, parent_id)
VALUES ('decision', '<what was decided>', '<rationale>', '<tags>', <brainstorm_id>);

Questions surfaced:

INSERT INTO logs (type, title, body, tags, parent_id)
VALUES ('question', '<the question>', '<context for why it matters>', '<tags>', <brainstorm_id>);

Insights:

INSERT INTO logs (type, title, body, tags, parent_id)
VALUES ('insight', '<the insight>', '<supporting reasoning>', '<tags>', <brainstorm_id>);

Tasks identified:

INSERT INTO logs (type, title, body, tags, pillar, parent_id)
VALUES ('task', '<actionable task>', '<context and acceptance criteria>', '<tags>', '<pillar>', <brainstorm_id>);

Announce each capture briefly: "Logged decision #N: ..." so the user knows it's recorded without breaking flow.

Step 5 — Close the brainstorm

When the conversation reaches a natural stopping point (or the user signals done):

  1. Update the brainstorm entry's body with a summary:
    UPDATE logs SET body = '<summary of what was discussed and concluded>'
    WHERE id = <brainstorm_id>;
  2. Count and report outputs:
    SELECT type, count(*) FROM logs WHERE parent_id = <brainstorm_id> GROUP BY type;
  3. Present a brief wrap-up: what was explored, what was decided, what questions remain open, and what tasks were created.
  4. Recalculate tiers (/brain, Recalculate tiers).

Focus Brainstorm

Start a brainstorm session anchored to the current focus items. Usage: /brainstorm focus

Procedure

  1. Load focus items:
    SELECT id, type, title, body, tags, pillar FROM logs
    WHERE focus = 1 AND status = 'active';
  2. Load related context — recent decisions, insights, and open questions connected to these focus items:
    SELECT id, type, title, substr(body, 1, 200) FROM logs
    WHERE status = 'active' AND type IN ('decision', 'insight', 'question')
    ORDER BY created_at DESC LIMIT 15;
  3. Create a brainstorm entry that references the focus items:
    INSERT INTO logs (type, title, body, tags, importance)
    VALUES ('note', 'Focus brainstorm: <combined topic from focus items>',
      'Brainstorm session on current focus items: <list titles and IDs>.',
      'brainstorm,focus', 7);
  4. Present the focus items, their descriptions, and related context. Then ask the user which focus item to start with, or whether to tackle them together (if they're related).
  5. Proceed with brainstorming (Steps 3-5 from New Brainstorm above). Keep the conversation grounded in the focus items — when outputs emerge, note which focus task they advance.

Hater Brainstorm

Pressure-test an idea like a skeptical investor or CTO would. Usage: /brainstorm hater <topic>

The goal is not to kill ideas — it's to make them stronger by surfacing risks, edge cases, and gaps in thinking before they become expensive surprises.

Procedure

Follow the same Steps 1, 2, 4, and 5 as New Brainstorm, with these modifications:

Step 1 — Create the brainstorm entry with tags brainstorm,hater:

INSERT INTO logs (type, title, body, tags, importance)
VALUES ('note', 'Hater: <topic title>', 'Hater brainstorm — pressure-testing assumptions.', 'brainstorm,hater', 6);

Step 3 — Brainstorm with a skeptic's lens. Replace the standard principles with:

  • Default to doubt. Assume the idea has a fatal flaw you haven't found yet. Your job is to find it — or confirm it's not there.
  • Attack the assumptions, not the person. Every plan rests on beliefs about the market, the user, the tech, the timeline. Name those beliefs explicitly, then stress-test each one. "This assumes X — what if X is wrong?"
  • Ask the investor questions. "What's the failure mode?", "Who else has tried this and what happened?", "What's the second-order effect?", "What does this look like at 10x scale?", "Where's the hidden cost?"
  • Find the edge cases. The happy path is easy. Probe the unhappy paths — the user who doesn't fit the model, the technical constraint that only shows up at scale, the regulatory angle nobody mentioned.
  • Be specific about risk. Don't say "this could be risky." Say "if churn exceeds 30% in month 2, this unit economics model breaks because..." Concrete scenarios, not vibes.
  • Steel-man before you attack. Before poking a hole, show you understand why the idea is compelling. Then explain why that's not enough.
  • Every criticism carries a suggestion. Never raise a risk without proposing at least one way to address it. "This breaks if X" is incomplete — "This breaks if X; you could mitigate by Y or validate with Z" is the standard. Unproductive negativity is a bug.
  • Flag research gaps honestly. When a risk or decision hinges on something neither of us actually knows — market data, technical benchmarks, competitor behavior, legal constraints — say so and suggest a /research topic. Don't pretend to have the answer and don't assume the user does either. Before suggesting research, check cowork/research/ for existing reports that already cover the topic. If a report exists, reference it instead of proposing redundant work.
  • Converge on what survives. The output isn't a graveyard of killed ideas — it's a ranked list of risks with severity and mitigation options, a set of questions that need answers before committing, and the core thesis restated with its actual (not imagined) strength.

Revisit

Continue a prior brainstorm. Usage: /brainstorm <id>

Procedure

  1. Load the brainstorm entry and all its children:
    SELECT id, type, title, body, tags FROM logs WHERE id = <id>;
    SELECT id, type, title, body, tags, status FROM logs WHERE parent_id = <id> ORDER BY created_at;
  2. Present the state: original topic, summary, and all outputs (decisions, questions, insights, tasks) with their current status.
  3. Ask the user what aspect they want to revisit or continue.
  4. Resume brainstorming — new outputs still link to the same parent via parent_id.

List

Show all brainstorms with output counts. Usage: /brainstorm list

Procedure

  1. Query:
    SELECT e.id, e.created_at, e.title,
      (SELECT count(*) FROM logs c WHERE c.parent_id = e.id) as outputs,
      (SELECT group_concat(DISTINCT c.type) FROM logs c WHERE c.parent_id = e.id) as output_types
    FROM logs e
    WHERE e.type = 'note' AND e.tags LIKE '%brainstorm%'
    ORDER BY e.created_at DESC;
  2. Present as a list with id, date, title, and output summary. Highlight any with open questions.

Global rules

  • No permission needed — Execute immediately without asking.
  • Log as you go — Capture outputs during the conversation, not after. The brain DB is the record.
  • Link everything — Every output entry must have parent_id set to the brainstorm entry's id.
  • Normalize tags — Split by comma, trim, lowercase, sort alphabetically, deduplicate, rejoin. Check existing tags (shown in dynamic context above) before inventing new ones.
  • DB is truth — The DB is the only copy of the brain. Always query it.
  • Decisions are permanent — Don't update a decision entry. If thinking changes, create a new decision that supersedes it (set supersedes column, mark old one superseded).

Project overrides

If .claude/kit.json has a rules."brainstorm" entry, read it and apply it as an additional instruction for this skill. Absent file or key means no overrides — that is the normal case.

jq -r '.rules."brainstorm" // empty' .claude/kit.json 2>/dev/null

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.