Technical design collaboration through natural dialogue. Adapts to expertise level and problem complexity through understanding, exploration, and validation stages. Use when user asks to brainstorm ideas for new features or systems requiring architectural decisions before implementation begins.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Technical design collaboration through natural dialogue. Adapts to expertise level and problem complexity through understanding, exploration, and validation stages. Use when user asks to brainstorm ideas for new features or systems requiring architectural decisions before implementation begins.
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.
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.
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.
