Agent skill

Brainstorm

by andrew-yangy in andrew-yangy/gru-ai

Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions.

MITAuto-check passedAgent Workflows

Install Brainstorm

skills CLI
$ npx skills add andrew-yangy/gru-ai --skill brainstorm -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install andrew-yangy/gru-ai brainstorm --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/andrew-yangy/gru-ai.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/brainstorm .claude/skills/brainstorm && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
brainstorm
GitHub stars
155
Token cost
~3.2k tokens
SKILL.md length
932 words
Files
1
Skills in repo
9
Repo updated
First seen
Licence
MIT

At a glance

Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions.

  • Works in 6 steps: Triage → Frame the Question → Diverge — Independent Perspectives → …
  • Tasks that involve Brainstorming
  • SKILL.md covers Role Resolution, Step 0: Triage, Lightweight Path — Socratic… and Heavyweight Path — Multi-Agent…, plus 8 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Brainstorm is an agent skill from andrew-yangy/gru-ai. Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions. The missing step before /directive: figure out WHAT to do before telling agents to DO it. Takes a question or topic as argument.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Agent Workflows, covering Brainstorming and Tutoring and explanations. The repository describes itself as: Autonomous AI agent team for one-man companies. Context engineering + harness engineering drive a pipeline that brainstorms, builds, reviews, and ships. The licence is MIT.

When your agent uses it

  • Tasks that involve Brainstorming
  • Tasks that involve Tutoring and explanations

Example prompts

  • “/brainstorm”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Triage
  2. Frame the Question
  3. Diverge — Independent Perspectives
  4. Converge — COO Synthesizes
  5. Present to CEO
  6. Capture Decision

What it can do on your machine

Read from SKILL.md and the folder at commit 8fba479. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Brainstorm loads about 3.2k tokens when it runs. Until then it costs about 57 tokens; SKILL.md has 932 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~57
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from andrew-yangy/gru-ai at commit 8fba479, republished under its MIT licence (© andrew-yangy). 932 words, ~3,190 tokens.

Download SKILL.mdSave it as .claude/skills/brainstorm/SKILL.md (or your agent's skills folder).
name
brainstorm
description
Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions. The missing step before /directive: figure out WHAT to do before telling agents to DO it. Takes a question or topic as argument.

Brainstorm — Structured Strategic Thinking

Role Resolution

Read .claude/agent-registry.json to map roles to agent names. Use each agent's id as the subagent_type when spawning. The COO = operations/orchestration, the CTO = architecture/technical, the CPO = product/UX, the CMO = growth/marketing.


The CEO has a question: $ARGUMENTS

Step 0: Triage

Read the question. Classify it before doing anything else.

Lightweight — single agent, Socratic dialogue, no external research:

  • Focused design question ("how should I structure this component?")
  • Single-domain topic (just architecture, or just UX, or just process)
  • Answer can be reached in one conversation
  • No cross-cutting impact (doesn't change multiple systems)

Heavyweight — multi-agent parallel research, synthesis, options:

  • Strategic question affecting multiple systems ("how should goal tracking work?")
  • Crosses domains (architecture + UX + operations)
  • Needs external research (how do others solve this?)
  • Decision has lasting consequences (data models, project structure, user flows)

State the classification:

Classification: {lightweight | heavyweight}
Reasoning: {one sentence}

Lightweight Path — Socratic Refinement

For focused questions. One agent, interactive dialogue. Think 5-minute whiteboard chat.

Pick the right agent based on the question domain:

  • Architecture / data model → the CTO
  • User experience / product → the CPO
  • Process / operations → the COO
  • Growth / positioning → the CMO

Spawn the agent (using the registry's id as subagent_type) with:

  • Their personality file (auto-loaded via subagent_type)
  • The CEO's question
  • .context/vision.md and .context/preferences.md
  • Relevant files the question touches
You are {Name}, {Title}. The CEO wants to think through a design question with you.

QUESTION: {question}

Your job: Socratic refinement. Don't jump to an answer. Instead:

1. CLARIFY — Ask 2-3 sharpening questions to make sure you understand what the CEO really needs. What are the constraints? What matters most? What have they already considered?

2. EXPLORE — Once you understand, propose 2 options with clear trade-offs. Be opinionated. "I'd go with A because..." not "both have merit."

3. DETAIL — After the CEO picks a direction, flesh it out: what changes, what the structure looks like, what to watch out for.

Keep it conversational. Short responses. This is a dialogue, not a report.

CRITICAL OUTPUT FORMAT: JSON only. First character `{`, last `}`.

{
  "agent": "{name}",
  "clarifying_questions": ["question 1", "question 2", "question 3"],
  "initial_instinct": "Your gut reaction to the question in 1-2 sentences"
}

After the agent asks questions, present them to the CEO via AskUserQuestion or as text. Let the CEO answer. Then re-spawn the agent (or resume) with the answers to get the options.

Final output: Write a brief design note to .context/directives/{relevant-directive}/brainstorm.md capturing the decision. Keep it short — this is a lightweight brainstorm, not a design doc.

If the question turns out to be bigger than expected (agent's questions reveal cross-cutting complexity), upgrade to heavyweight. Tell the CEO: "This is bigger than it looked — upgrading to full brainstorm."


Heavyweight Path — Multi-Agent Strategy Session

For strategic questions. Full C-suite, parallel research, synthesis, options.

The pattern: Diverge (independent perspectives) → Converge (synthesize options) → Decide (CEO picks) → Capture (design doc).

Step 1: Frame the Question

Read the CEO's question. If it's vague, clarify it with AskUserQuestion before proceeding.

Read context:

  • .context/vision.md — current north star
  • .context/preferences.md — CEO preferences
  • .context/goals/*/goal.json — current goal structure
  • .context/lessons/scenarios.md — standing user scenarios (if relevant)

Frame the question as a clear design challenge:

  • What we're deciding: one sentence
  • Why it matters: what breaks if we get this wrong
  • Constraints: non-negotiables from vision.md or preferences.md
  • Current state: how things work today (brief)

Show the framing to the CEO before spawning agents. This prevents wasted work on a misunderstood question.

Step 2: Diverge — Independent Perspectives

Spawn 2-3 C-suite agents in parallel. Pick the most relevant agents for the question domain:

  • Architecture / data model / system design → the CTO
  • User experience / product design / workflows → the CPO
  • Operations / process / project structure → the COO
  • Growth / positioning / external patterns → the CMO

Always include the COO (they synthesize in Step 3). Pick 1-2 others based on the question.

Each agent receives:

  • Their personality from .claude/agents/{name}.md
  • The framed question from Step 1
  • .context/vision.md and .context/preferences.md
  • Relevant context files (goal structure, current system docs, etc.)
  • These instructions:
You are {Name}, {Title}. The CEO is brainstorming a strategic question and wants your independent perspective.

QUESTION: {framed question}
CURRENT STATE: {how it works today}
CONSTRAINTS: {non-negotiables}

Your job:
1. RESEARCH first — use WebSearch if external patterns would help (how do other tools/frameworks handle this?). Use Read/Grep/Glob if you need to understand the current system.
2. THINK from your domain expertise — what matters most from your perspective?
3. PROPOSE — give 1-2 concrete options with trade-offs. Don't hedge. Have an opinion.

Structure your response:

{
  "agent": "{name}",
  "perspective": "Your 2-3 sentence framing of the problem from your domain",
  "research": [
    {
      "finding": "What you found externally or internally",
      "source": "URL or file path",
      "relevance": "Why it matters to this question"
    }
  ],
  "proposals": [
    {
      "name": "short-name",
      "summary": "One paragraph describing the approach",
      "pros": ["advantage 1", "advantage 2"],
      "cons": ["disadvantage 1", "disadvantage 2"],
      "effort": "quick (hours) | medium (days) | large (weeks)",
      "opinion": "Why you'd pick this one (or not)"
    }
  ],
  "non_negotiables": ["Things that MUST be true regardless of which option we pick"],
  "watch_outs": ["Risks or gotchas the CEO should know about"]
}

CRITICAL: First character `{`, last character `}`. JSON only. Have a STRONG opinion — the CEO wants perspectives, not waffling.

All agents: subagent_type: "general-purpose", model: "opus".

Step 3: Converge — COO Synthesizes

After all agents return, spawn the COO with a synthesis task.

The COO receives:

  • Their personality
  • All agent outputs from Step 2
  • The original framed question
  • Vision + preferences
You are the COO. The team has brainstormed independently. Your job: synthesize their perspectives into 2-3 clear OPTIONS for the CEO to choose from.

AGENT PERSPECTIVES:
{all agent outputs}

SYNTHESIS RULES:
1. Find the OVERLAPS — where do agents agree? This is the foundation.
2. Find the CONFLICTS — where do they disagree? These are the real decision points.
3. Design 2-3 OPTIONS that represent genuinely different approaches (not just variations).
4. For each option, be honest about trade-offs. Don't create a strawman "bad option" to make one look good.
5. Include a "COO'S PICK" — your recommendation with reasoning.
6. Include the NON-NEGOTIABLES that all agents agreed on (these apply regardless of option).

{
  "agreements": ["Things all agents agreed on — the foundation"],
  "tensions": [
    {
      "topic": "What they disagree about",
      "positions": {"sarah": "her view", "marcus": "his view"},
      "why_it_matters": "What depends on this decision"
    }
  ],
  "options": [
    {
      "name": "Option A: descriptive name",
      "summary": "2-3 sentence description",
      "inspired_by": ["which agent roles/perspectives contributed"],
      "pros": ["advantages"],
      "cons": ["disadvantages"],
      "effort": "quick | medium | large",
      "best_when": "This option is best if the CEO values X over Y"
    }
  ],
  "non_negotiables": ["Must be true regardless of option chosen"],
  "coo_pick": {
    "option": "Option name",
    "reasoning": "Why — in 2-3 sentences"
  }
}

CRITICAL: First character `{`, last character `}`. JSON only.

Step 4: Present to CEO

Present the synthesized options in a readable format:

# Brainstorm: {question title}

## The Team Agrees On
{non-negotiables — things that are true regardless of direction}

## The Key Tensions
{where agents disagreed — these are the real decisions}

## Options

### Option A: {name}
{summary}
**Pros:** {list}
**Cons:** {list}
**Effort:** {estimate}
**Best if:** {when to pick this}

### Option B: {name}
...

### Option C: {name} (if applicable)
...

## COO's Recommendation
{COO's pick and reasoning}

## Research Highlights
{Most interesting external findings from agents — URLs included}

Ask the CEO using AskUserQuestion:

  • Option A / Option B / Option C / "Hybrid — let me explain"
Show full SKILL.md (410 more words)Show less

Step 5: Capture Decision

After the CEO decides:

  1. Write a design doc to .context/directives/{relevant-directive}/brainstorm.md:

    markdown
    # {Question Title}
    Date: {date}
    Decision: {chosen option}
    Participants: {agents involved}
    
    ## Context
    {framed question + why it matters}
    
    ## Options Considered
    {brief summary of each option}
    
    ## Decision
    {which option + CEO's reasoning}
    
    ## Non-Negotiables
    {agreed constraints}
    
    ## Next Steps
    {what needs to happen to implement this — becomes /directive input}
  2. If the decision requires implementation, ask the CEO:

    • "Create directive" — write a directive to directives/ based on the decision
    • "Add to backlog" — write to the relevant goal's backlog
    • "Design doc only" — just capture the decision, implement later

Failure Handling

SituationAction
Agent output doesn't parseLog error, continue with others. 2/3 perspectives is fine.
Agents all agreeGreat — present the consensus as the recommendation. Still offer 2 options (the consensus + a contrarian alternative).
CEO wants to explore furtherSpawn additional research on the specific area. Don't re-run the whole brainstorm.
Question is too broadBreak it into sub-questions. Brainstorm the most foundational one first.

How Brainstorm Fits the Conductor Flow

Normal path (auto-triggered): Strategic directives trigger a brainstorm automatically inside the /directive pipeline. The CEO never needs to invoke /brainstorm separately — the team detects when strategic thinking is needed and handles it.

CEO gives direction → /directive → triage as "strategic" → C-suite brainstorms → COO plans → execute

Standalone path (CEO-invoked): The CEO can still invoke /brainstorm directly for questions that don't need a directive — strategy decisions, process design, framework choices, or "I want to think through X with the team" moments.

CEO invokes /brainstorm → triage → lightweight or heavyweight brainstorm → design doc

Not every directive needs a brainstorm (simple fixes don't). But strategic work — new data models, workflow changes, architectural shifts — benefits from the team exploring approaches before the COO plans execution.

Rules

NEVER
  • Skip triage (Step 0) — always classify before spawning
  • Use heavyweight for a focused question (wastes tokens and CEO time)
  • Use lightweight for a strategic question (misses perspectives)
  • Start heavyweight agents without framing the question first (Step 1)
  • Let heavyweight agents see each other's output during Step 2 (independent thinking prevents groupthink)
  • Present more than 3 options (decision paralysis)
  • Skip the COO's synthesis in heavyweight (raw perspectives without synthesis is a data dump)
ALWAYS
  • Triage first — lightweight or heavyweight
  • Capture the decision to a discussion file (reasoning dies in context windows)
  • Upgrade lightweight → heavyweight if clarifying questions reveal cross-cutting complexity
  • Include at least the COO + one other agent for heavyweight
  • Have the COO state a recommendation for heavyweight (no "it depends" cop-outs)
  • Include external research in heavyweight (agents should WebSearch, not just opine)
  • Frame the question before spawning heavyweight agents (prevents wasted work)

© andrew-yangy, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/brainstorm of andrew-yangy/gru-ai.

Open the folder on GitHubat commit 8fba479

Compare with similar skills

Brainstorm next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Brainstorm compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Brainstorm this skillandrew-yangy/gru-ai155—~3.2kAutomated safety check: PassMIT
Brainstorminged3dai/ed3d-plugins2501 repos~4.3kAutomated safety check: PassNone
Socratic BrainstormTheBeardedBearSAS/claude-craft107—~1.2kAutomated safety check: PassMIT
Gsd Exploreopen-gsd/gsd-core10k2 repos~176Automated safety check: NotesMIT
BrainstormingxenitV1/Antigravity-Workflows130—~1.1kAutomated safety check: PassMIT
Yao Bayesian Skillyaojingang/yao-open-skills1.3k—~956Automated safety check: PassMIT

Similar skills

  • Brainstorming

    ed3dai/ed3d-plugins

    A skill your agent uses when creating or developing anything, before writing code or implementation plans - refines rough ideas into fully-formed designs through structured Socratic questioning…

    250 GitHub starsUsed in 1 repo~4.3k tokens
    Agent WorkflowsAuto-check passed
  • Socratic Brainstorm

    TheBeardedBearSAS/claude-craft

    Brainstorming socratique AVANT de coder - clarifier le problème par questions ciblées plutôt que sauter à la solution.

    107 GitHub stars~1.2k tokensUpdated 25 days ago
    Agent WorkflowsAuto-check passed
  • Gsd Explore

    open-gsd/gsd-core

    Socratic ideation and idea routing — think through ideas before committing to plans

    10k GitHub starsUsed in 2 repos~176 tokens
    Agent WorkflowsAuto-check: notes
  • Brainstorming

    xenitV1/Antigravity-Workflows

    Socratic questioning protocol + user communication. An agent skill from xenitV1/Antigravity-Workflows.

    130 GitHub stars~1.1k tokensUpdated 8 mo ago
    Agent WorkflowsAuto-check passed
  • Yao Bayesian Skill

    yaojingang/yao-open-skills

    Convert uncertain real-world choices into an auditable Bayesian evidence-to-action report with priors, evidence grading, posterior update, action thresholds, sensitivity checks, multi-turn decision…

    1.3k GitHub stars~956 tokensUpdated 1 mo ago
    EducationAuto-check passed
  • Yao Gametheory Skill

    yaojingang/yao-open-skills

    Route CEO-facing competition, negotiation, channel, pricing, platform, M&A, financing, competitor-response, alliance, and regulator problems through an applied game-theory framework router when…

    1.3k GitHub stars~1k tokensUpdated 1 mo ago
    Documents & OfficeAuto-check passed

More from andrew-yangy/gru-ai

All 9 skills in this repo
  • Code Review Excellence

    andrew-yangy/gru-ai

    Provides comprehensive code review guidance for React 19, Vue 3, Rust, TypeScript, Java, Python, and C/C++.

    155 GitHub stars~1.7k tokensUpdated 7 mo ago
    Auto-check: notes
  • SEO Audit

    andrew-yangy/gru-ai

    Full website SEO audit with parallel subagent delegation. An agent skill from andrew-yangy/gru-ai.

    155 GitHub stars~731 tokensUpdated 7 mo ago
    Auto-check passed
  • Healthcheck

    andrew-yangy/gru-ai

    Internal codebase and operations health check — the CTO scans technical health, the COO checks operational health.

    155 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed
  • Report

    andrew-yangy/gru-ai

    CEO dashboard with progressive disclosure — 3 tiers: headline (5 lines, default), summary (per-goal detail), deep (full weekly analysis).

    155 GitHub stars~4k tokensUpdated 7 mo ago
    Auto-check passed
  • Smoke Test

    andrew-yangy/gru-ai

    Pipeline end-to-end smoke test -- creates a trivial directive, runs it through /directive, validates every pipeline step, and reports pass/fail with evidence.

    155 GitHub stars~941 tokensUpdated 7 mo ago
    Auto-check passed
  • Directive

    andrew-yangy/gru-ai

    Execute work through the directive pipeline — evaluate, plan, cast agents, build, review, and report.

    155 GitHub stars~2.8k tokensUpdated 7 mo ago
    Auto-check: warnings

Categories

Questions about Brainstorm

What does Brainstorm do?

Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions. Brainstorm is an agent skill from andrew-yangy/gru-ai. Structured brainstorm — from quick Socratic refinement to full C-suite strategy sessions.

When should I use Brainstorm?

Brainstorm fits situations like: tasks that involve Brainstorming; tasks that involve Tutoring and explanations.

How do I install Brainstorm in Claude Code?

Run `npx skills add andrew-yangy/gru-ai --skill brainstorm -a claude-code`. Or copy the skill folder (.claude/skills/brainstorm in andrew-yangy/gru-ai) into .claude/skills/brainstorm in your project. Claude Code loads it when a task matches its description.

How do I install Brainstorm in Codex?

Run `npx skills add andrew-yangy/gru-ai --skill brainstorm -a codex`. Or copy the skill folder (.claude/skills/brainstorm in andrew-yangy/gru-ai) into .agents/skills/brainstorm in your project. Codex loads it when a task matches its description.

Can I use Brainstorm in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add andrew-yangy/gru-ai --skill brainstorm -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/brainstorm, .gemini/skills/brainstorm, .github/skills/brainstorm and .opencode/skills/brainstorm in your project.

What does Brainstorm need to run?

SKILL.md names no scripts, command-line tools or credentials: Brainstorm is instructions for the agent only.

Does Brainstorm access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Brainstorm safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Brainstorm use?

Brainstorm is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Brainstorm use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Brainstorm?

Skills that share tags, products or a category with Brainstorm: Brainstorming (ed3dai/ed3d-plugins, 250 stars), Socratic Brainstorm (TheBeardedBearSAS/claude-craft, 107 stars), Gsd Explore (open-gsd/gsd-core, 10k stars) and Brainstorming (xenitV1/Antigravity-Workflows, 130 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Brainstorm?

andrew-yangy (a GitHub user) maintains it in andrew-yangy/gru-ai, which has 155 GitHub stars. The repository holds 9 skills in this directory. The repository was last updated on March 11, 2026.

Source: andrew-yangy/gru-ai on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.