Skip to main content
skill CX Codex

brainstorm · rsmdt — Claude Code skill: what it does, how to install

brainstorm guides interactive feature planning before touching code. Asks single questions, outlines implementation approaches with trade-offs, and documents design decisions.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup
Open on GitHub

What brainstorm does

The skill keeps the agent from diving straight into code. It forces Claude to inspect current project context first, including git history and repository conventions. The agent then asks questions one by one to clarify goals, audience, and technical boundaries.

Next, it presents two or three distinct approaches with explicit pros and cons, recommending the best fit. Once you pick an approach, the agent details the design across architecture, data flow, and testing strategy. Any fresh scope introduced during review goes straight to a parking lot list instead of bloating the current plan.

Implementation skills and code generation are explicitly forbidden throughout this process. You can export the finalized design into .start/ideas/YYYY-MM-DD-<topic>.md or hand it directly over to the specify skill.

What it helps with

  • validate feature requirements before drafting code
  • compare two or three architecture approaches with trade-offs
  • prevent scope creep during design iterations
  • save validated feature plans into .start/ideas/

Example prompts for the agent

  • brainstorm design a Redis caching layer for API endpoints
  • /brainstorm refactor user auth to JWT with role-based access
  • brainstorm add background webhook processing for billing events

How to install brainstorm

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install start@the-startup

This installs the whole start plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill brainstorm -a claude-code

3Manually: put the files in place

~/.claude/skills/brainstorm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/brainstorm/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about brainstorm

How to install brainstorm in Claude Code?

Run /plugin marketplace add rsmdt/the-startup in Claude Code, then run /plugin install start@the-startup. Alternatively, install it with npx skills add rsmdt/the-startup --skill brainstorm -a claude-code.

What does brainstorm do?

It acts as a design partner that clarifies intent, evaluates architectural trade-offs, and documents system structure before any implementation starts.

Does brainstorm generate production code?

No. The skill strictly bans writing code, scaffolding project folders, or invoking build tools until the user approves the architecture.

Source text

SKILL.md · MIT
---
name: brainstorm
description: "Required first step before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements, and design before implementation."
user-invocable: true
argument-hint: "describe what you want to build or explore"
---

## Persona

Act as a collaborative design partner that turns ideas into validated designs through natural dialogue. Probe before prescribing — understand the full picture before proposing solutions.

**Idea**: $ARGUMENTS

## Interface

Approach {
  name: string
  description: string
  tradeoffs: { pros: string[], cons: string[] }
  recommended: boolean
}

DesignSection {
  topic: string               // e.g., architecture, data flow, error handling
  complexity: Low | Medium | High
  status: Pending | Presented | Approved | Revised
}

State {
  target = $ARGUMENTS
  projectContext = ""
  approaches: Approach[]
  design: DesignSection[]
  approved = false
}

## Constraints

**Always:**
- Explore project context before asking questions.
- Ask ONE question per message — break complex topics into multiple turns.
- Propose 2-3 approaches with trade-offs before settling on a design.
- Lead with your recommended approach and explain why.
- Scale design depth to complexity — a few sentences for simple topics, detailed sections for nuanced ones.
- Get user approval on design before concluding.
- Apply YAGNI ruthlessly — strip unnecessary features from all designs.

**Never:**
- Write code, scaffold projects, or invoke implementation skills during brainstorming.
- Present a design without first probing the idea and exploring approaches.
- Assume requirements — when uncertain, ask.
- Skip brainstorming because the idea "seems simple" — simple ideas need the least probing, not zero probing.
- Let scope expand during design revisions — new requirements go to a "parking lot", not into the current design.
- Treat the user's stated technology as a settled decision — it's one approach among several until validated.

## Red Flags — STOP If You Catch Yourself Thinking

| Thought | Reality |
|---------|---------|
| "This is too simple to brainstorm" | Simple features hide assumptions. Quick probe, brief design. |
| "The user said 'start coding'" | Urgency cues don't override design discipline. Probe first. |
| "I'll ask all questions upfront for efficiency" | Question dumps overwhelm. One question shapes the next. |
| "They said REST, so REST it is" | Stated technology = starting point, not settled decision. |
| "I already know the right approach" | You know A approach. The user deserves 2-3 to choose from. |
| "We already discussed this before" | Prior context informs, but doesn't replace this session's probing. |
| "They're an expert, they don't need options" | Even experts benefit from seeing trade-offs laid out. |

## Workflow

### 1. Explore Context

Check project files, documentation, and recent git commits.

Identify:
- Existing patterns and conventions.
- Related code or features.
- Technical constraints (language, framework, dependencies).

Build a mental model of current project state.

### 2. Probe Idea

Ask questions ONE AT A TIME to understand:
- Purpose — what problem does this solve?
- Users — who benefits and how?
- Constraints — budget, timeline, technical limitations?
- Success criteria — how do we know it works?

Prefer structured options when choices exist. Use open-ended questions when the space is too broad for options.

Continue until you have enough context to propose approaches.

### 3. Explore Approaches

Propose 2-3 distinct approaches, each with clear trade-offs (pros, cons). Lead with the recommended approach and reasoning.

Present conversationally, not as a formal document.

Ask the user to choose: [Approach 1 (Recommended)] | [Approach 2] | [Approach 3] | Hybrid

### 4. Present Design

Present design in sections, scaled to complexity:
- Low complexity — 1-3 sentences.
- Medium — short paragraph with key decisions.
- High — detailed section (up to 200-300 words).

Cover relevant topics: architecture, components, data flow, error handling, testing strategy.

After each section, ask if it looks right so far.

match (feedback) {
  approved  => move to next section
  revise    => adjust and re-present
  backtrack => return to step 2 or step 3
  new scope => add to parking lot, do NOT expand current design
}

If the user introduces new requirements during revision, acknowledge them and add to a "parking lot" list. Do NOT fold them into the current design. Present parking lot items at step 5.

### 5. Conclude

Present complete design summary.

Ask the user to choose:
  Save design to file — write to .start/ideas/YYYY-MM-DD-<topic>.md
  Start specification — continue with the specify skill using the design context
  Done — keep design in conversation only

© Rudolf S. · MIT · rsmdt/the-startup

Similar skills

All skills for Agent setup: memory, context, orchestration →

brainstorm by other authors comes first.

brainstorm Donchitos brainstorm walks you from a blank page or a rough idea to a one-page game brief in design/game-brief.md. Handy at project start and during game jams. CX Codex +1 831installs brainstorm NeoLabHQ brainstorm turns rough project ideas into detailed specifications through guided dialogue. It compares six architectural options before any code or implementation planning begins. CX Codex +1 1,400installs brainstorm buiducnhat brainstorm frames ambiguous or risky tasks through guided dialogue before coding. Clarifies project constraints, compares approaches, and writes a design brief. CX Codex +1 628installs brainstorm hyperb1iss brainstorm — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode helps explore open product or architecture questions. It compares paths before implementation. CX Codex +1 615installs brainstorm OrchestKit The brainstorm skill explores a design question with parallel agents, filters ideas for feasibility, and compares trade-offs. It does not build or fix code. CX Codex +1 133installs bmad-brainstorm aj-geddes bmad-brainstorm runs structured ideation sessions using SCAMPER, SWOT, and 5 Whys. Delivers an organized markdown report ready for project planning. CX Codex +1 130installs core-brainstorm LukeRenton core-brainstorm is a Claude Code skill for exploring a problem or shaping a feature idea before planning. It discusses the work without writing code or changing project files. CX Codex +1 ★ 333repo stars ce-brainstorm EveryInc ce-brainstorm turns vague ideas into a structured requirements plan through dialogue. Separates product decisions from code. CX Codex +1 4,200installs brainstorming sickn33 brainstorming turns raw ideas into validated design specifications through structured dialogue. It helps plan feature architecture before any code implementation starts. CX Codex +1 2,400installs oma-brainstorm First Fluke oma-brainstorm — a skill for Claude Code and Codex designed for early feature exploration before task planning. Clarifies ambiguous requests one question at a time and compares technical options. CX Codex +1 ★ 1,472repo stars tlc-discover Tech Leads Club - github.com/tech-leads-club tlc-discover — a skill for Claude Code and Codex turns vague project concepts into structured design docs. Structures discovery through an interview before any technical architecture is chosen. CX Codex +1 ★ 7,191repo stars

From the same set50

The whole set →
design-interaction design-interaction is a Claude Code subagent that designs navigation, user flows, and information architecture. Activates for onboarding redesigns and complex content organization. CX Codex ★ 587repo stars analyze analyze conducts deep research into a codebase or topic, validates every claim with adversarial verifiers, and delivers cited reports. CX Codex +1 ★ 587repo stars test-strategy The test-strategy subagent for Claude Code plans and runs risk-prioritized functional and performance checks, assessing coverage, bottlenecks, and release readiness. CX Codex ★ 587repo stars testing testing — a skill for writing effective tests: layer-specific mocking rules, failure debugging, flaky test management. CX Codex +1 ★ 587repo stars architecture-selection architecture-selection is a Claude Code skill that compares architecture patterns against project needs and documents a recommendation. It supports system planning, scalability reviews, and technology choices. CX Codex +1 ★ 587repo stars security-assessment security-assessment — a Claude skill that runs a security audit: STRIDE threat modelling, OWASP-based code review, and findings ranked by severity with fixes. CX Codex +1 ★ 587repo stars technical-writing technical-writing drafts architecture decision records, system architecture overviews, API references, and operations runbooks directly in your codebase. CX Codex +1 ★ 587repo stars refactor The refactor skill analyzes a chosen part of a codebase and guides step-by-step cleanup while preserving behavior. Use it to improve readability without changing business logic. CX Codex +1 ★ 587repo stars

Project sponsors

Companies that keep this analytics open