Agent skill
brainstorming
Use when creating or developing anything, before writing code or implementation plans - refines rough ideas into fully-formed designs through structured Socratic questioning, alternative exploration, and incremental validation
Install this agent skill to your Project
npx add-skill https://github.com/ArieGoldkin/ai-agent-hub/tree/main/skills/brainstorming
SKILL.md
Brainstorming Ideas Into Designs
Overview
Transform rough ideas into fully-formed designs through structured questioning and alternative exploration.
Core principle: Ask questions to understand, explore alternatives, present design incrementally for validation.
Announce skill usage at start of session.
When to Use This Skill
Activate this skill when:
- Request contains "I have an idea for..." or "I want to build..."
- User asks "help me design..." or "what's the best approach for..."
- Requirements are vague or high-level
- Multiple approaches might work
- Before writing any code or implementation plans
The Three-Phase Process
| Phase | Key Activities | Tool Usage | Output |
|---|---|---|---|
| 1. Understanding | Ask questions (one at a time) | AskUserQuestion for choices | Purpose, constraints, criteria |
| 2. Exploration | Propose 2-3 approaches | AskUserQuestion for approach selection | Architecture options with trade-offs |
| 3. Design Presentation | Present in 200-300 word sections | Open-ended questions | Complete design with validation |
Phase 1: Understanding
Goal: Gather purpose, constraints, and success criteria.
Process:
- Check current project state in working directory
- Ask ONE question at a time to refine the idea
- Use AskUserQuestion tool when presenting multiple choice options
- Gather: Purpose, constraints, success criteria
Tool Usage: Use AskUserQuestion for clarifying questions with 2-4 clear options.
Example: "Where should the authentication data be stored?" with options for Session storage, Local storage, Cookies, each with trade-off descriptions.
See references/example-session-auth.md for complete Phase 1 example.
Phase 2: Exploration
Goal: Propose 2-3 different architectural approaches with explicit trade-offs.
Process:
- Propose 2-3 different approaches
- For each: Core architecture, trade-offs, complexity assessment
- Use AskUserQuestion tool to present approaches as structured choices
- Include trade-off comparison table when helpful
Trade-off Format:
| Approach | Pros | Cons | Complexity |
|---|---|---|---|
| Option 1 | Benefits | Drawbacks | Low/Med/High |
| Option 2 | Benefits | Drawbacks | Low/Med/High |
| Option 3 | Benefits | Drawbacks | Low/Med/High |
See references/example-session-dashboard.md for complete Phase 2 example with SSE vs WebSockets vs Polling comparison.
Phase 3: Design Presentation
Goal: Present complete design incrementally, validating each section.
Process:
- Present in 200-300 word sections
- Cover: Architecture, components, data flow, error handling, testing
- Ask after each section: "Does this look right so far?"
- Use open-ended questions to allow freeform feedback
Typical Sections:
- Architecture overview
- Component details
- Data flow
- Error handling
- Security considerations
- Implementation priorities
Validation Pattern: After each section, pause for feedback before proceeding to next section.
Tool Usage Guidelines
Use AskUserQuestion Tool For:
- Phase 1: Clarifying questions with 2-4 clear options
- Phase 2: Architectural approach selection (2-3 alternatives)
- Any decision with distinct, mutually exclusive choices
- When options have clear trade-offs to explain
Benefits:
- Structured presentation of options with descriptions
- Clear trade-off visibility
- Forces explicit choice (prevents vague "maybe both" responses)
Use Open-Ended Questions For:
- Phase 3: Design validation
- When detailed feedback or explanation is needed
- When the user should describe their own requirements
- When structured options would limit creative input
Non-Linear Progression
Flexibility is key. Go backward when needed - don't force linear progression.
Return to Phase 1 when:
- User reveals new constraint during Phase 2 or 3
- Validation shows fundamental gap in requirements
- Something doesn't make sense
Return to Phase 2 when:
- User questions the chosen approach during Phase 3
- New information suggests a different approach would be better
Continue forward when:
- All requirements are clear
- Chosen approach is validated
- No new constraints emerge
Key Principles
| Principle | Application |
|---|---|
| One question at a time | Phase 1: Single question per message, use AskUserQuestion for choices |
| Structured choices | Use AskUserQuestion tool for 2-4 options with trade-offs |
| 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 |
| Flexible progression | Go backward when needed - flexibility > rigidity |
After Brainstorming Completes
Consider these optional next steps:
- Document the design in project's design documentation
- Break down the design into actionable implementation tasks
- Create a git branch or workspace for isolated development
Use templates in assets/design-doc-template.md and assets/decision-matrix-template.md for structured documentation.
Examples
Complete brainstorming sessions:
references/example-session-auth.md- Authentication storage design (JWT vs Session vs Cookies)references/example-session-dashboard.md- Real-time dashboard design (SSE vs WebSockets vs Polling)
Output templates:
assets/design-doc-template.md- Structured design document formatassets/decision-matrix-template.md- Weighted decision comparison format
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
security-checklist
Use this skill when implementing security measures or conducting security audits. Provides OWASP Top 10 mitigations, authentication patterns, input validation strategies, and compliance guidelines. Ensures applications are secure against common vulnerabilities.
prototype-to-production
Convert design prototypes (HTML, CSS, Figma exports) into production-ready components. Analyzes prototype structure, extracts design tokens, identifies reusable patterns, and generates typed React components. Adapts to existing project tech stack with React + TypeScript as default.
Performance Optimization
Full-stack performance analysis, optimization patterns, and monitoring strategies
ai-native-development
Build AI-first applications with RAG pipelines, embeddings, vector databases, agentic workflows, and LLM integration. Master prompt engineering, function calling, streaming responses, and cost optimization for 2025+ AI development.
react-server-components-framework
Design and implement React Server Components with Next.js 15 App Router. Master server-first architecture, streaming SSR, Server Actions, and modern data fetching patterns for 2025+ frontend development.
testing-strategy-builder
Use this skill when creating comprehensive testing strategies for applications. Provides test planning templates, coverage targets, test case structures, and guidance for unit, integration, E2E, and performance testing. Ensures robust quality assurance across the development lifecycle.
Didn't find tool you were looking for?