← Back to skills

Development Process

Brainstorming

Collaborative idea-to-design exploration that asks clarifying questions, proposes approaches with tradeoffs, and iterates toward a design.

Last reviewed Mar 2, 2026

Install

Create this file in your project:

.claude/skills/brainstorming/SKILL.md
--- name: brainstorming description: Use this skill when exploring ideas, designing features, evaluating approaches, or when the user wants to think through a problem before implementing. --- # Brainstorming ## When to Use - Starting a new feature or project from scratch - Evaluating multiple technical approaches - The user says "let's think about," "how should we," or "what's the best way to" - Requirements are unclear and need exploration ## Process 1. **Clarify** -- Ask clarifying questions one at a time. Prefer multiple-choice questions over open-ended ones to reduce decision fatigue. Wait for the answer before asking the next question. 2. **Propose** -- Present 2-3 distinct approaches, each with a brief description, key tradeoffs (pros/cons), and a recommendation. Keep descriptions concise. 3. **Iterate** -- Once an approach is selected, break the design into logical sections. Present each section for review and approval before moving to the next. 4. **Converge** -- Summarize the final design decisions in a clear, actionable format that can be handed off to implementation. ## Rules - Ask one question at a time. Never dump a list of 10 questions. - Prefer multiple-choice questions: "Should we use A, B, or C?" not "What should we use?" - Apply YAGNI ruthlessly. Push back on features that aren't needed yet. - Always explore at least two alternatives before recommending one. - Separate "must have" requirements from "nice to have" during clarification. - Do not start implementing during brainstorming. The output is a design, not code. - If the user jumps to implementation details too early, gently redirect to design-level decisions first.

What this skill does

Brainstorming is a structured exploration skill that helps you move from a vague idea to a concrete design through guided conversation. Instead of the AI immediately generating code, it first asks the right questions, proposes multiple approaches with honest tradeoffs, and iterates toward a design that the human actually wants.

The one-question-at-a-time approach is deliberate. When AI assistants dump a list of questions, users feel overwhelmed and often give incomplete answers. By asking sequentially with multiple-choice options, the conversation flows naturally and surfaces important constraints early.

The skill also enforces YAGNI (You Ain't Gonna Need It) discipline. AI assistants often over-engineer solutions by anticipating future requirements that may never materialize. This skill pushes back on unnecessary complexity and focuses on what's needed now.

Example workflow

You say: "I want to add user authentication to my app." The agent will:

  1. Ask: "What type of app is this -- a) Next.js web app, b) React Native mobile app, c) Full-stack with API?" You answer (a).
  2. Ask: "Which auth providers do you need -- a) Email/password only, b) Social logins (Google, GitHub), c) Both?" You answer (c).
  3. Ask: "Do you need role-based access control, or just authenticated vs. anonymous?" You answer just authenticated.
  4. Propose: Option A (NextAuth.js), Option B (Clerk), Option C (Supabase Auth) -- with tradeoffs for each.
  5. You pick Clerk. Agent then walks through the design: session management, protected routes, middleware setup -- one section at a time.

Tips

  • Use this skill before jumping into implementation -- 20 minutes of design saves hours of rework
  • If the agent proposes something overly complex, say "simpler" and it will strip back
  • The multiple-choice format works well for quick decisions; say "none of these" if you have a different idea
  • Brainstorming output pairs well with the Writing Plans skill for creating an implementation plan

Best with tools

    Related MCP servers

    • No linked MCP servers yet.

    Related skills

    Executing Plans

    Execute implementation plans task-by-task with verification checkpoints, sequential ordering, and frequent commits.

    Systematic Debugging

    Enforces a structured debugging workflow: reproduce, hypothesize, verify, fix root cause, and audit similar code paths.

    Test-Driven Development

    Enforces the red-green-refactor cycle so every feature starts with a failing test before any implementation code is written.