llblab/brainstorming

Brainstorming

Turn rough ideas into clear, implementation-ready designs through lightweight collaborative exploration.

This skill is intentionally independent. It does not require or name any other skill, project, repository, framework, or workflow. It composes by producing clean design truth that surrounding processes can store, review, plan, or implement in their own way.

Purpose

Use this skill when the useful next step is clarification rather than immediate execution:

• New feature or behavior design
• Architecture or module-boundary choices
• Standards / protocol drafting
• Product or ecosystem-shaping decisions
• UI/UX concept exploration
• Scope decomposition before implementation
• Risky changes where intent and constraints matter more than speed

Do not use it as bureaucracy for obvious mechanical edits, typo fixes, direct user-specified changes, or emergency fixes with clear acceptance criteria. For small work, a two-sentence design note is enough.

Core Contract

Brainstorming produces one of:

1. A concise approved direction
2. A written design/specification
3. A decomposed set of smaller slices
4. A decision to stop or defer

Implementation may begin once design uncertainty for the current slice is resolved. Approval can be explicit (yes, approved, do it) or implicit when the user directly asks to implement the proposed direction.

Operating Principles

• Ask only what changes the design.
• Prefer one question at a time.
• Prefer multiple-choice questions when they reduce friction.
• Lead with the recommended option after enough context is known.
• Keep alternatives concrete and trade-off based.
• Use the smallest design artifact that preserves shared understanding.
• Separate portable mechanism from product-specific content.
• Treat durable context, documentation, and open-work state as part of design truth.
• Avoid speculative architecture. Add complexity only when a discovered constraint earns it.
• Preserve local vocabulary instead of importing new ontology unnecessarily.

Composition Contract

This skill should fit into any surrounding workflow without knowing its names.

Context systems

If the repository has a living context protocol, align with it before designing and leave outputs in the expected places. Typical durable surfaces are:

• Contributor/agent instructions for durable rules
• Backlog/roadmap for open work
• Changelog/history for completed delivery
• Root and subtree README files for human navigation
• Documentation indexes and subsystem docs for contracts and architecture

Brainstorming decides what should exist; the local context protocol decides where that truth belongs.

Implementation workflows

After design acceptance, hand off to the local implementation workflow. Do not prescribe a specific planning or coding skill. The next step may be a plan, a small patch, a prototype, a review, or a backlog item depending on project norms.

Review workflows

When the design is risky, broad, or security-sensitive, request an evidence-grounded review before implementation. A good review handoff names the artifact, assumptions, alternatives rejected, and open risks.

Execution loops

When the accepted direction contains many small tasks, define stop conditions and let the local execution process iterate. Brainstorming should not become the execution loop itself.

Portability Lens

When designing for systems intended to be reused, forked, extended, or installed in multiple contexts, classify each idea:

• Mandatory kernel: required for the base system to function
• Optional module: useful but disableable/omittable
• Reference implementation: example/default, not a universal mandate
• Tooling/operations: helps build, launch, observe, or maintain
• Product-specific layer: belongs to a particular downstream instance

Prefer designs where optional capability is modular, documented, and easy to disable. A module is not harmful merely because some instances do not need it; it becomes harmful when it is presented as unavoidable core, leaks policy into neutral layers, or creates hidden dependencies.

Useful portability questions:

• Can another instance reuse this without adopting this product's identity or politics?
• Is this mechanism, policy, content, or narrative?
• Can it be parameterized instead of hardcoded?
• Can it be disabled without breaking the base path?
• Does it create hidden infrastructure, indexer, service, or operator assumptions?
• Which document or interface becomes the source of truth?

Extension/Platform Lens

When designing extensible systems, keep the layers distinct:

• Loader/discovery: how extensions/modules are found
• Identity: how ownership and conflicts are named
• Registry: how capabilities are registered/unregistered
• Routing: how events/actions/callbacks reach owners
• Runtime ports: what safe capabilities owners receive
• Diagnostics: how users/operators see registered state and failures
• Fallbacks: what happens when an owner is missing or stale

Prefer stable identity keys, narrow typed ports, explicit ownership, and graceful stale-state behavior. Avoid passing raw internals when a smaller port captures the real need.

Useful extension questions:

• Who owns this action/callback/event?
• What is the smallest safe capability surface?
• Is this a low-level hook or a structured UI/API surface?
• What happens when the owner disappears?
• How are conflicts diagnosed?

Process

1. Orient

Read the nearest relevant project context before proposing design:

• Local contributor instructions
• Backlog or roadmap
• Root README and relevant subtree README files
• Documentation index and relevant docs
• Recent delivery history when shipped baseline matters
• Existing code only when implementation constraints shape the design

For small or conversational work, summarize only the relevant facts. Do not dump context.

2. Classify Scope

Classify the request:

Tiny:        obvious design, compact note enough
Small:       one feature/module, few choices
Medium:      needs alternatives and a short spec
Large:       decompose into slices before designing slice 1
Ambiguous:   ask one blocking question first

If the request spans independent subsystems, decompose before designing details.

3. Clarify

Ask one useful question at a time until the main uncertainty is resolved.

Prefer questions about:

• Goal / success criteria
• User or operator workflow
• Hard constraints
• Ownership boundary
• Data/state lifecycle
• Safety and rollback
• What must be portable vs product-specific

Skip questions when the user already gave enough constraints for a safe first design.

4. Offer Approaches

Present 2–3 approaches when real trade-offs exist.

For each approach include:

• What it optimizes
• What it costs
• When it fails

Lead with your recommendation.

Compact format:

Recommendation: B.

A. Minimal patch — fastest, but narrow.
B. Modular contract — slightly more work, best future fit.
C. Platform layer — powerful, premature unless X is true.

5. Present Design

Scale the design to the work.

Cover only relevant sections:

• Goal
• Non-goals
• Scope boundary
• Concepts / vocabulary
• Architecture / module ownership
• Data flow / lifecycle
• API or contract shape
• UX behavior
• Error/stale/edge behavior
• Security/capabilities
• Tests/validation
• Documentation/backlog updates
• Rollout plan

Ask for approval when the next step would commit the design into durable docs, backlog, or implementation.

6. Choose Artifact

Pick the smallest durable artifact that matches the project:

• No artifact: ephemeral clarification only
• Backlog item: future work only
• Short doc section: small standard/behavior update
• Full spec/design doc: medium or large design
• Architecture/decision note: durable trade-off or boundary decision

Follow existing project naming and location conventions. Do not force a new spec directory. Do not commit unless the user or repository workflow requires it.

7. Self-Review

Before handing off, check:

• No TBD / vague placeholders unless intentionally marked open
• No contradiction with existing project docs
• Scope is implementable as one slice, or explicitly decomposed
• Terminology matches local vocabulary
• Optional vs mandatory modules are labeled honestly
• Data/state ownership is clear
• Validation path is named

8. Handoff

End with the next concrete step:

• “Approve this direction and I’ll implement it.”
• “I’ll add this to the backlog.”
• “I’ll draft the documentation section.”
• “Next step is a focused implementation plan.”
• “Next step is evidence review before implementation.”

Design Quality Heuristics

A good brainstormed design is:

• Easy to remove if wrong
• Easy to test in isolation
• Honest about ownership
• Honest about what is optional
• Small enough to ship
• Compatible with existing project memory
• Clear about what it refuses to solve

Warning signs:

• New ontology for one local edge case
• Hidden indexer or service dependency
• Optional module presented as framework core
• Callback/action ownership unclear
• “Generic platform” proposed before a second real user exists
• Design doc duplicates facts already owned elsewhere
• Backlog closes work that only docs discussed but implementation did not land

Visual Aids

Use visual aids only when the decision is genuinely visual: UI layouts, diagrams, flows, spatial comparisons, or architecture maps.

Do not interrupt text-first brainstorming with visual tooling for conceptual choices.

If a local visual companion exists, offer it once before using it:

Some of this may be easier with diagrams or mockups. Want a visual companion, or should we keep it text-only?

If no such tool exists, use concise ASCII diagrams or Markdown sketches.