Brainstorming Ideas Into Designs
Overview
Help turn ideas into fully formed designs and specs through natural collaborative dialogue.
Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.
The Process
Understanding the idea:
- Check out the current project state first (files, docs, recent commits)
- Ask questions one at a time to refine the idea
- Prefer multiple choice questions when possible, but open-ended is fine too
- Only one question per message - if a topic needs more exploration, break it into multiple questions
- Focus on understanding: purpose, constraints, success criteria
Exploring approaches:
- Propose 2-3 different approaches with trade-offs
- Present options conversationally with your recommendation and reasoning
- Lead with your recommended option and explain why
Presenting the design:
- Once you believe you understand what you're building, present the design
- Break it into sections of 200-300 words
- Ask after each section whether it looks right so far
- Cover: architecture, components, data flow, error handling, testing
- Be ready to go back and clarify if something doesn't make sense
After the Design
Documentation:
- Write the validated design to
docs/plans/YYYY-MM-DD-<topic>-design.md
- Use context-compressor skill if available for efficient documentation
- Commit the design document to git
Implementation (if continuing):
- Ask: "Ready to set up for implementation?"
- Use writing-plans skill to create detailed implementation plan
Key Principles
- One question at a time - Don't overwhelm with multiple questions
- Multiple choice preferred - Easier to answer than open-ended when possible
- YAGNI ruthlessly - Remove unnecessary features from all designs
- Explore alternatives - Always propose 2-3 approaches before settling
- Incremental validation - Present design in sections, validate each
- Be flexible - Go back and clarify when something doesn't make sense
Iron Laws
- NEVER propose a single solution — always surface 2–3 distinct approaches with trade-offs; a single solution forecloses exploration and anchors the user prematurely.
- ALWAYS apply YAGNI (You Ain't Gonna Need It) — challenge every feature or complexity not directly required by the stated problem; unneeded features become permanent maintenance debt.
- NEVER ask multiple questions in one response — one focused question at a time maintains dialogue flow; multiple questions cause partial answers and leave the most important question unanswered.
- ALWAYS prefer multiple-choice over open-ended questions — specific options reduce cognitive load; open-ended questions require the user to invent answers rather than evaluate them.
- NEVER proceed to implementation details until design decisions are confirmed — premature implementation locks in unvalidated assumptions; confirm the "what" and "why" before the "how".
Anti-Patterns
| Anti-Pattern |
Why It Fails |
Correct Approach |
| Proposing only one solution |
Anchors user; forecloses better alternatives |
Always offer 2-3 approaches with explicit trade-offs |
| Accepting first requirement as complete |
First articulation rarely captures all constraints |
Ask at least one clarifying question about scope |
| Asking 3+ questions at once |
User answers the easy ones; skips the hard ones |
One question per response; wait for answer |
| Jumping to implementation |
Design flaws found late are expensive to fix |
Confirm design decisions before writing code |
| Skipping YAGNI challenge |
Unneeded features accumulate as tech debt |
Explicitly challenge each feature not strictly required |
Memory Protocol (MANDATORY)
Before starting:
Read .claude/context/memory/learnings.md
After completing:
- New pattern ->
.claude/context/memory/learnings.md
- Issue found ->
.claude/context/memory/issues.md
- Decision made ->
.claude/context/memory/decisions.md
ASSUME INTERRUPTION: If it's not in memory, it didn't happen.
1---2name: brainstorming3description: Socratic design refinement before implementation — challenges assumptions, surfaces alternatives, identifies risks before code is written4version: 1.1.05model: sonnet6invoked_by: both7user_invocable: true8tools: [Read, Write, Bash]9agents: [developer, planner, architect]10category: 'Planning & Architecture'11tags: [brainstorming, design, planning, ideation, socratic]1213verified: true14lastVerifiedAt: 2026-02-22T08:50:27.367Z15best_practices:16 - Ask one question at a time17 - Prefer multiple choice over open-ended18 - Enforce YAGNI19 - Explore 2-3 alternative approaches20error_handling: graceful21streaming: supported22source: builtin23trust_score: 10024provenance_sha: 4d97e8ca56ab52b025metadata:26 source: https://skillmd.com/skills/oimiragieo/brainstorming27---2829# Brainstorming Ideas Into Designs3031## Overview3233Help turn ideas into fully formed designs and specs through natural collaborative dialogue.3435Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.3637## The Process3839**Understanding the idea:**4041- Check out the current project state first (files, docs, recent commits)42- Ask questions one at a time to refine the idea43- Prefer multiple choice questions when possible, but open-ended is fine too44- Only one question per message - if a topic needs more exploration, break it into multiple questions45- Focus on understanding: purpose, constraints, success criteria4647**Exploring approaches:**4849- Propose 2-3 different approaches with trade-offs50- Present options conversationally with your recommendation and reasoning51- Lead with your recommended option and explain why5253**Presenting the design:**5455- Once you believe you understand what you're building, present the design56- Break it into sections of 200-300 words57- Ask after each section whether it looks right so far58- Cover: architecture, components, data flow, error handling, testing59- Be ready to go back and clarify if something doesn't make sense6061## After the Design6263**Documentation:**6465- Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`66- Use context-compressor skill if available for efficient documentation67- Commit the design document to git6869**Implementation (if continuing):**7071- Ask: "Ready to set up for implementation?"72- Use writing-plans skill to create detailed implementation plan7374## Key Principles7576- **One question at a time** - Don't overwhelm with multiple questions77- **Multiple choice preferred** - Easier to answer than open-ended when possible78- **YAGNI ruthlessly** - Remove unnecessary features from all designs79- **Explore alternatives** - Always propose 2-3 approaches before settling80- **Incremental validation** - Present design in sections, validate each81- **Be flexible** - Go back and clarify when something doesn't make sense8283## Iron Laws84851. **NEVER propose a single solution** — always surface 2–3 distinct approaches with trade-offs; a single solution forecloses exploration and anchors the user prematurely.862. **ALWAYS apply YAGNI (You Ain't Gonna Need It)** — challenge every feature or complexity not directly required by the stated problem; unneeded features become permanent maintenance debt.873. **NEVER ask multiple questions in one response** — one focused question at a time maintains dialogue flow; multiple questions cause partial answers and leave the most important question unanswered.884. **ALWAYS prefer multiple-choice over open-ended questions** — specific options reduce cognitive load; open-ended questions require the user to invent answers rather than evaluate them.895. **NEVER proceed to implementation details until design decisions are confirmed** — premature implementation locks in unvalidated assumptions; confirm the "what" and "why" before the "how".9091## Anti-Patterns9293| Anti-Pattern | Why It Fails | Correct Approach |94| --------------------------------------- | -------------------------------------------------- | ------------------------------------------------------- |95| Proposing only one solution | Anchors user; forecloses better alternatives | Always offer 2-3 approaches with explicit trade-offs |96| Accepting first requirement as complete | First articulation rarely captures all constraints | Ask at least one clarifying question about scope |97| Asking 3+ questions at once | User answers the easy ones; skips the hard ones | One question per response; wait for answer |98| Jumping to implementation | Design flaws found late are expensive to fix | Confirm design decisions before writing code |99| Skipping YAGNI challenge | Unneeded features accumulate as tech debt | Explicitly challenge each feature not strictly required |100101## Memory Protocol (MANDATORY)102103**Before starting:**104Read `.claude/context/memory/learnings.md`105106**After completing:**107108- New pattern -> `.claude/context/memory/learnings.md`109- Issue found -> `.claude/context/memory/issues.md`110- Decision made -> `.claude/context/memory/decisions.md`111112> ASSUME INTERRUPTION: If it's not in memory, it didn't happen.