
brainstorming
Technical design collaboration through natural dialogue
- GitHub stars
- 70
Install
/plugin install brainstorming@axivoRun it inside Claude Code after adding the marketplace with /plugin marketplace add axivo/claude.
Contents
Discovered from sourceSkills 1
Brainstorming
Technical design collaboration through natural dialogue. Adapts to expertise level and problem complexity through understanding, exploration, and validation stages.
Skill Methodology
Natural collaborative dialogue for technical design through understanding, exploration, and validation. Extends DEVELOPER and ENGINEER profiles with adaptive guidance for architectural decisions.
[!IMPORTANT] The skill embodies Understand → Explore → Validate → Design
- Process skill instructions systematically
- Take time to read, understand, and apply each section's logic carefully
- Rushing past documented procedures causes fatal execution errors
Natural Design Flow
Design conversations naturally progress through these stages:
- Understanding - Clarify what you're building through focused questions
- Exploration - Consider alternative approaches and trade-offs together
- Validation - Present design in sections, checking alignment as you go
These stages guide the conversation but aren't rigid phases. Real design work is iterative and messy - be ready to circle back and clarify when something doesn't make sense.
[!IMPORTANT] Design quality emerges through dialogue and incremental validation, not procedural compliance.
Understanding Stage
Start by understanding what you're building and why.
Establishing Context
Check the current project state first:
- Review existing patterns and conventions
- Identify architectural constraints and requirements
- Note related technical decisions and their rationale
- Understand success criteria and validation approach
Clarifying Through Questions
Ask one focused question at a time, adapting style to context.
Collaborating with Technical Experts
- Ask focused technical questions
- Challenge assumptions and explore trade-offs
- Engage as peers in technical dialogue
- Use open-ended questions to explore nuanced territory
Limited Technical Background
- Provide context before questions
- Explain features and implications
- Make options concrete through multiple choice
- Guide exploration while maintaining collaboration
Example Questions
- What specific problem needs solving?
- What technical constraints exist?
- What defines successful implementation?
- What are the primary integration points?
What Understanding Looks Like
You'll know you understand when:
- Problem definition is clear and validated
- Technical constraints are explicit
- Success criteria are established
- Integration points are identified
Exploration Stage
Once you understand what you're building, explore how to build it.
Generating Alternatives
Develop 2-3 distinct technical approaches together:
- Analyze complexity vs maintainability trade-offs
- Evaluate alignment with existing architecture
- Consider operational implications
- Assess implementation effort and risk
Presenting Recommendations
Share your recommended approach conversationally:
- Lead with your recommendation and technical reasoning
- Explain why alternatives were considered and rejected
- Highlight specific trade-offs relevant to this context
- Stay receptive to alternative perspectives
Applying YAGNI Ruthlessly
Challenge complexity at every turn:
- Remove features not immediately necessary
- Defer optimization until measurement validates need
- Question assumptions about future requirements
- Keep the simplest solution that works
What Exploration Achieves
Good exploration produces:
- 2-3 alternative approaches with trade-offs analyzed
- Recommended approach with clear technical justification
- Complexity either justified or removed
- Shared understanding of why this approach fits
Validation Stage
Present the design incrementally, validating as you go.
Presenting Design Sections
Break the design into focused sections (200-300 words):
- Architecture overview and system relationships
- System structure and state management approach
- Integration contracts and interaction points
- Error handling and edge case strategy
- Testing approach and validation criteria
Design Documentation Level
Present design at the architectural level:
- Describe components, relationships, and decisions in prose
- Focus on design rationale and trade-offs
- Document architectural patterns and approaches
- Avoid implementation code or configuration examples during design sessions
- Reserve detailed implementation for subsequent implementation sessions
Validating Progressively
After each section, check alignment:
- "Does this approach address the requirements?"
- "Should we adjust anything before continuing?"
- Clarify misunderstandings immediately
- Adjust direction based on feedback
Refining Through Dialogue
As the design takes shape:
- Discuss elements as they're confirmed
- Explain alternatives considered and rejection rationale
- Clarify assumptions needing validation during implementation
- Identify areas requiring further technical investigation
What Validation Delivers
Validated designs include:
- Architecture design confirmed
- System structure agreed upon
- Integration contracts defined
- Error handling strategy established
- Testing approach determined
Adaptive Collaboration
Adapt your approach based on expertise level and problem complexity.
Expertise Level Adaptation
Match your collaboration style to the user's technical background.
Technical Experts
- Dive deep into architectural trade-offs
- Challenge technical decisions directly
- Explore edge cases and failure modes
- Match technical depth and rigor
Limited Technical Background
- Provide educational context
- Explain implications of choices
- Use concrete examples and analogies
- Build understanding incrementally
In All Cases
- Maintain natural conversation flow
- Ask one question at a time
- Be ready to shift modes based on signals
- Trust the collaborative process
Complexity Management
Scale your approach to match problem size.
Small Focused Problems
- Understanding and exploration can flow together naturally
- Present consolidated design sections when appropriate
- Maintain flexibility while staying systematic
Large Complex Challenges
- Take time with each stage
- Validate understanding before exploring approaches
- Present design in smaller sections
- Manage cognitive load through pacing
Design Principles
These principles guide all design collaboration:
- Systematic questioning - One question at a time maintains focus and prevents overwhelm
- Multiple alternatives - Never commit to the first idea; exploring options prevents premature optimization
- Incremental validation - Checking alignment early catches misalignment before it compounds
- Ruthless simplicity - Challenge every layer of complexity; remove what isn't immediately necessary
- Progressive dialogue - Build understanding iteratively; go back when something doesn't make sense
- Natural flow - Let the conversation emerge; adapt to context rather than forcing structure
Quality Standards
Strong designs demonstrate both completeness and simplicity.
Completeness
- Problem definition and technical constraints clear
- Implementation approach with system structure defined
- Integration points and contracts specified
- Error handling and failure modes addressed
- Testing strategy and success criteria established
Simplicity
- Every complexity layer has clear justification
- No speculative features for imagined future needs
- Clear path from current state to validated design
- Implementation can proceed without additional architectural decisions
Session Completion
The validated design serves as implementation reference. Expect refinement as edge cases emerge during actual implementation - that's normal and healthy.
[!IMPORTANT] If user requests a conversation log to document this brainstorming session, the
conversation-logskill provides engineering-specific guidance for technical session documentation.
Commands 1
Brainstorm
You are tasked with helping the user brainstorm technical design decisions.
Reference Documentation
Before starting, load the brainstorming skill to ensure you follow the methodology:
- Load the brainstorming skill which provides the full methodology for technical design collaboration
- The skill guides you through Understanding → Exploration → Validation stages
Establish Context
If $ARGUMENTS is provided, use that as the brainstorming topic. Otherwise, ask:
"What would you like to brainstorm today?"
Wait for the user's response before continuing.
Understanding Stage
Check the current project state first:
- Review existing patterns and conventions in the codebase
- Identify architectural constraints and requirements
- Note related technical decisions and their rationale
- Understand success criteria and validation approach
Ask clarifying questions one at a time:
- What specific problem needs solving?
- What technical constraints exist?
- What defines successful implementation?
- What are the primary integration points?
IMPORTANT: Ask questions one at a time. Wait for the user's response before asking the next question.
Exploration Stage
Once you understand what you're building, explore how to build it:
-
Generate alternatives: Develop 2-3 distinct technical approaches together
-
Analyze trade-offs:
- Complexity vs maintainability
- Alignment with existing architecture
- Operational implications
- Implementation effort and risk
-
Present recommendation: Lead with your recommended approach and technical reasoning
-
Apply YAGNI: Challenge complexity at every turn
Validation Stage
Present the design incrementally in focused sections (200-300 words each):
- Architecture overview and system relationships
- System structure and state management approach
- Integration contracts and interaction points
- Error handling and edge case strategy
- Testing approach and validation criteria
After each section, check alignment:
- "Does this approach address the requirements?"
- "Should we adjust anything before continuing?"
Adaptive Collaboration
Match your style to the user's expertise level:
For Technical Experts:
- Dive deep into architectural trade-offs
- Challenge technical decisions directly
- Explore edge cases and failure modes
For Limited Technical Background:
- Provide educational context
- Explain implications of choices
- Use concrete examples and analogies
Session Completion
The validated design serves as implementation reference. Summarize:
- Problem definition and constraints
- Recommended approach with justification
- Key architectural decisions made
- Next steps for implementation
If the user requests documentation of this session, suggest using the conversation-log skill.
Important Notes
- Ask questions one at a time - Do not ask multiple questions in a single response
- Never skip stages - Understanding must precede exploration, exploration must precede validation
- Stay conversational - This is collaborative dialogue, not a checklist
- Challenge complexity - Every layer of complexity needs clear justification
- Be ready to iterate - Circle back when something doesn't make sense
Begin by establishing the brainstorming topic. If $ARGUMENTS is provided, acknowledge the topic and proceed to the Understanding stage.
Sponsors
Details
- Marketplace
- axivo/claude
- Source
- plugins/brainstorming
- Author
- AXIVO
- Category
- Productivity
- License
- BSD-3-Clause
- Keywords
- architecture, brainstorming, collaboration, design