brainstorming_skill

Overview

This skill enforces a design-first methodology that turns ideas into validated, implementable specs through collaborative dialogue. It guides teams to understand intent, ask focused questions, and produce incremental design sections before any code is written. The process reduces rework and clarifies success criteria, constraints, and edge cases.

How this skill works

The skill inspects project context (files, recent commits, and existing patterns) and then drives a one-question-at-a-time discovery using structured multiple-choice or open responses. It always presents 2–3 alternative approaches with trade-offs, leads with a recommended option, and breaks the approved design into 200–300 word sections for iterative validation. Before finalizing plans it mandates verification of any third-party library (e.g., using npm info) and requires at least one counter-architecture to challenge the recommendation.

When to use it

• Before adding new features or building new components
• When changing core behavior or adding significant functionality
• For tasks expected to take more than 30 minutes
• When multiple teams or stakeholders must align on scope
• Skip only for trivial fixes, docs edits, or obvious small config changes

Best practices

• Ask one focused question at a time and prefer multiple-choice responses
• Always present 2–3 approaches with clear pros, cons, and a recommended option
• Validate any third-party dependency with a package registry check before recommending it
• Break the design into 200–300 word sections and confirm after each section
• Include a steel‑man counter-architecture to surface trade-offs and avoid bias

Example use cases

• Designing a new authentication flow for a web app with stakeholder alignment
• Planning a refactor of a core component where backward compatibility matters
• Scoping a feature that integrates external services and requires dependency review
• Creating a testing and error-handling strategy for a critical path
• Drafting a production-ready architecture versus a quick prototype trade-off