playbooks

home / skills / nilecui / skillsbase / brainstorming

brainstorming skill

/.cursor/skills/brainstorming

This skill helps you transform rough ideas into fully formed designs by guiding structured Socratic questioning and presenting incremental options.

npx playbooks add skill nilecui/skillsbase --skill brainstorming

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.8 KB
---
name: Brainstorming Ideas Into Designs
description: Interactive idea refinement using Socratic method to develop fully-formed designs
when_to_use: when partner describes any feature or project idea, before writing code or implementation plans
version: 2.2.0
---

# 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 at start:** "I'm using the Brainstorming skill to refine your idea into a design."

## The Process

### Phase 1: Understanding
- Check current project state in working directory
- Ask ONE question at a time to refine the idea
- Prefer multiple choice when possible
- Gather: Purpose, constraints, success criteria

### Phase 2: Exploration
- Propose 2-3 different approaches
- For each: Core architecture, trade-offs, complexity assessment
- Ask your human partner which approach resonates

### Phase 3: Design Presentation
- Present in 200-300 word sections
- Cover: Architecture, components, data flow, error handling, testing
- Ask after each section: "Does this look right so far?"

### Phase 4: Worktree Setup (for implementation)
When design is approved and implementation will follow:
- Announce: "I'm using the Using Git Worktrees skill to set up an isolated workspace."
- Switch to skills/collaboration/using-git-worktrees
- Follow that skill's process for directory selection, safety verification, and setup
- Return here when worktree ready

### Phase 5: Planning Handoff
Ask: "Ready to create the implementation plan?"

When your human partner confirms (any affirmative response):
- Announce: "I'm using the Writing Plans skill to create the implementation plan."
- Switch to skills/collaboration/writing-plans skill
- Create detailed plan in the worktree

## When to Revisit Earlier Phases

**You can and should go backward when:**
- Partner reveals new constraint during Phase 2 or 3 → Return to Phase 1 to understand it
- Validation shows fundamental gap in requirements → Return to Phase 1
- Partner questions approach during Phase 3 → Return to Phase 2 to explore alternatives
- Something doesn't make sense → Go back and clarify

**Don't force forward linearly** when going backward would give better results.

## Related Skills

**During exploration:**
- When approaches have genuine trade-offs: skills/architecture/preserving-productive-tensions

**Before proposing changes to existing code:**
- Understand why it exists: skills/research/tracing-knowledge-lineages

## Remember
- One question per message during Phase 1
- Apply YAGNI ruthlessly
- Explore 2-3 alternatives before settling
- Present incrementally, validate as you go
- Go backward when needed - flexibility > rigid progression
- Announce skill usage at start

Overview

This skill guides interactive refinement of rough ideas into fully-formed designs using a Socratic, question-driven approach. It begins by announcing that it is being used and then iterates through understanding, exploration, incremental presentation, and handoff phases. The goal is validated, implementable designs that align with constraints and success criteria.

How this skill works

The skill inspects the current project context and asks one focused question at a time to gather purpose, constraints, and success criteria. It then proposes 2–3 distinct approaches, outlining architecture, trade-offs, and complexity for each, and asks which resonates. Approved approaches are presented in 200–300 word design sections covering architecture, components, data flow, error handling, and testing. If implementation will follow, it coordinates a safe worktree setup and creates a detailed implementation plan via specialized handoff skills.

When to use it

  • You have a rough idea that needs structure before design or implementation.
  • Requirements are high-level or ambiguous and need clarification through guided questions.
  • You want alternative technical approaches and clear trade-offs before committing.
  • You need incremental validation of a design with your team or stakeholder.
  • You plan to move from design to implementation and want a safe worktree and plan handoff.

Best practices

  • Ask one clear question per message during the initial understanding phase.
  • Prefer multiple-choice questions to speed alignment and reduce ambiguity.
  • Explore 2–3 alternative approaches before selecting a direction.
  • Present designs in short, reviewable sections and ask for confirmation after each.
  • Be willing to step back to earlier phases when new constraints or gaps appear.

Example use cases

  • Turn a product concept into a validated system design with defined success criteria.
  • Compare three backend architectures for scalability, cost, and implementation speed.
  • Refine UI/UX ideas into concrete component designs and data flows.
  • Prepare a design and safe worktree when transitioning from architecture to implementation.
  • Create a test and error-handling strategy for a proposed feature before coding.

FAQ

How many questions do you ask at once during discovery?

One question per message to keep focus and encourage precise answers.

What happens if requirements change mid-design?

We return to the understanding phase, update constraints, re-explore alternatives, and continue incrementally.