axivo avatar

brainstorming

Technical design collaboration through natural dialogue

GitHub stars
70

Install

/plugin install brainstorming@axivo

Run it inside Claude Code after adding the marketplace with /plugin marketplace add axivo/claude.

Contents

Discovered from source

Skills 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:

  1. Understanding - Clarify what you're building through focused questions
  2. Exploration - Consider alternative approaches and trade-offs together
  3. 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-log skill 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:

  1. Load the brainstorming skill which provides the full methodology for technical design collaboration
  2. 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:

  1. Review existing patterns and conventions in the codebase
  2. Identify architectural constraints and requirements
  3. Note related technical decisions and their rationale
  4. 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:

  1. Generate alternatives: Develop 2-3 distinct technical approaches together

  2. Analyze trade-offs:

    • Complexity vs maintainability
    • Alignment with existing architecture
    • Operational implications
    • Implementation effort and risk
  3. Present recommendation: Lead with your recommended approach and technical reasoning

  4. Apply YAGNI: Challenge complexity at every turn

Validation Stage

Present the design incrementally in focused sections (200-300 words each):

  1. Architecture overview and system relationships
  2. System structure and state management approach
  3. Integration contracts and interaction points
  4. Error handling and edge case strategy
  5. 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:

  1. Problem definition and constraints
  2. Recommended approach with justification
  3. Key architectural decisions made
  4. 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

More from axivo/claude

All 4