К основному содержанию
скилл CX Codex

brainstorm · yonatangross — скилл для Claude Code: идеи и установка

Скилл brainstorm собирает варианты решения через параллельных агентов, фильтрует их по реализуемости и помогает сравнить компромиссы. Код он не строит и не чинит.

MIT 133 установок ★ 305 обновлён 2026-11-14

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add yonatangross/orchestkit --skill brainstorm -a claude-code
Открыть на GitHub

Что делает brainstorm

brainstorm превращает расплывчатую задачу в набор вариантов дизайна. Скилл запускает параллельное исследование, собирает 10+ идей, отбрасывает слабые по реализуемости решения и просит агентов сыграть роль критиков. На выходе получается сравнение подходов с их компромиссами.

Перед подбором агентов он изучает контекст проекта: определяет его уровень сложности, загружает предыдущие решения и уточняет ограничения через вопросы. Выбор режима зависит от задачи: можно сравнить 2–3 подхода, быстро накидать идеи или пройти более глубокую оценку. Результаты фаз передаются дальше через handoff-файлы.

Для Claude Code нужен memory MCP-сервер и версия 2.1.277 или новее. Это скилл для проектирования и выбора направления, а не для написания или исправления кода: такие запросы направляются в implement или fix-issue.

Какие задачи решает

  • собрать 10+ вариантов архитектуры
  • сравнить 2–3 подхода к одной задаче
  • отфильтровать идеи по реализуемости
  • найти компромиссы между вариантами
  • проверить концепцию через критику агентов

Примеры запросов агенту

  • Запусти brainstorm и предложи варианты архитектуры для системы уведомлений.
  • Сравни через brainstorm подходы к обработке обновлений в реальном времени.
  • Помоги с brainstorm для архитектуры модуля биллинга и учти ограничения проекта.

Как установить brainstorm

1Через Skills CLI (Vercel)

npx skills add yonatangross/orchestkit --skill brainstorm -a claude-code

2Вручную: положить файлы

~/.claude/skills/brainstorm/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/brainstorm/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о brainstorm

Как установить brainstorm в Claude Code?

Выполните npx skills add yonatangross/orchestkit --skill brainstorm -a claude-code, затем откройте файл ~/.claude/skills/brainstorm/SKILL.md.

Что делает скилл brainstorm?

Он исследует идею через параллельных агентов, предлагает 10+ вариантов, оценивает реализуемость и показывает компромиссы. Скилл помогает выбрать направление, но не занимается сборкой или исправлением кода.

Что нужно для работы brainstorm?

Для Claude Code требуется версия 2.1.277 или новее и memory MCP-сервер.

Исходный текст

SKILL.md · MIT
---
name: brainstorm
license: MIT
compatibility: "Claude Code 2.1.277+. Requires memory MCP server."
description: "Design ideation with parallel agents: 10+ ideas, feasibility filter, devil's-advocate scoring, trade-offs. Use when brainstorming or comparing alternatives. Not for building or fixing code (use implement or fix-issue) or scoring a design (use assess)."
argument-hint: "[topic-or-idea]"
disable-model-invocation: false  # #3194: true also blocked USER-typed mid-turn invocations
user-invocable: true
allowed-tools: "AskUserQuestion Agent Workflow Read Grep Glob Bash TaskCreate TaskUpdate TaskList TaskStop ToolSearch ExitWorktree PushNotification mcp__memory__search_nodes"
skills: [architecture-decision-record, api-design, memory, remember, scope-appropriate-architecture, testing-unit, testing-integration, chain-patterns, design-to-code, component-search, design-context-extract, security-patterns, database-patterns, performance, devops-deployment, competitive-analysis, user-research, browser-tools]
model: sonnet
metadata:
  category: workflow-automation
  mcp-server: memory
  version: "4.10.0"
  author: "OrchestKit"
  complexity: "medium"
  tags: "planning, ideation, creativity, design"
triggers:
  keywords: [brainstorm, brianstorm, "explore ideas", "explore some ideas", ideate, "think through", "some approaches", "not sure how to architect", alternatives, "compare strategies", "help me compare"]
  examples:
    - "brainstorm how to build the notification system"
    - "what are some approaches for handling real-time updates"
    - "im not sure how to architect the billing module"
  anti-triggers: [implement, build, fix, commit, review, assess, rate]
---

# Brainstorming Ideas Into Designs

Host-neutral workflow. Invoke by skill name (`brainstorm`). Claude Code slash routing, YAML hook loaders, and `.claude/chain` live in `references/claude-code.md`.

Transform rough ideas into fully-formed designs through intelligent agent selection and structured exploration.

**Core principle:** Analyze the topic, select relevant agents dynamically, explore alternatives in parallel, present design incrementally.

## Argument Resolution

```python
TOPIC = "$ARGUMENTS"  # Full argument string, e.g., "API design for payments"
# $ARGUMENTS[0] is the first token (CC 2.1.59 indexed access)
```

---

## STEP -1: MCP Probe + Resume Check

Probe MCP servers once at skill start, store capabilities, and resume from any prior crashed session. Each phase emits a JSON handoff file consumed by the next.

Full procedure + handoff-file table: `Read("references/mcp-probe-resume.md")`

---

## STEP 0: Project Context Discovery

**Context already loaded.** Claude Code ran these loaders when it opened this skill (a fork never runs frontmatter hooks, and a body step can be skipped, #4683). Keep each `additionalContext` below in mind; there is nothing to run. A blank line means that loader had nothing to add. If you see `[shell command execution disabled by policy]` instead, run `skill/prior-decisions-loader` and `skill/brainstorm-instructions-loader` yourself, each as `echo '{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{}}' | node "${CLAUDE_PLUGIN_ROOT}/hooks/bin/run-hook.mjs" <loader>`:

!`echo '{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{}}' | node "${CLAUDE_SKILL_DIR}/../../hooks/bin/run-hook.mjs" skill/prior-decisions-loader 2>/dev/null || true`

!`echo '{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{}}' | node "${CLAUDE_SKILL_DIR}/../../hooks/bin/run-hook.mjs" skill/brainstorm-instructions-loader 2>/dev/null || true`

**BEFORE creating tasks or selecting agents**, detect the project tier. This becomes the **complexity ceiling** for all downstream decisions.

### Auto-Detection (scan codebase)

```python
# PARALLEL — quick signals (launch all in ONE message)
Grep(pattern="take-home|assignment|interview|hackathon", glob="README*", output_mode="content")
Grep(pattern="take-home|assignment|interview|hackathon", glob="*.md", output_mode="content")
Glob(pattern=".github/workflows/*")
Glob(pattern="**/Dockerfile")
Glob(pattern="**/terraform/**")
Glob(pattern="**/k8s/**")
Glob(pattern="CONTRIBUTING.md")
```

### Tier Classification

| Signal | Tier |
|--------|------|
| README says "take-home", "assignment", time limit | **1. Interview** |
| < 10 files, no CI, no Docker | **2. Hackathon** |
| `.github/workflows/`, 10-25 deps | **3. MVP** |
| Module boundaries, Redis, background jobs | **4. Growth** |
| K8s/Terraform, DDD structure, monorepo | **5. Enterprise** |
| CONTRIBUTING.md, LICENSE, minimal deps | **6. Open Source** |

**If confidence is low**, ask the user:

```python
AskUserQuestion(questions=[{
  "question": "What kind of project is this?",
  "header": "Project tier",
  "options": [
    {"label": "Interview / take-home", "description": "8-15 files, 200-600 LOC, simple architecture"},
    {"label": "Startup / MVP", "description": "MVC monolith, managed services, ship fast"},
    {"label": "Growth / enterprise", "description": "Modular monolith or DDD, full observability"},
    {"label": "Open source library", "description": "Minimal API surface, exhaustive tests"}
  ],
  "multiSelect": false
}])
```

**Pass the detected tier as context to ALL downstream agents and phases.** The tier constrains which patterns are appropriate — see `scope-appropriate-architecture` skill for the full matrix.

> **Override:** User can always override the detected tier. Warn them of trade-offs if they choose a higher tier than detected.

---

## STEP 0a: Verify User Intent with AskUserQuestion

**Clarify brainstorming constraints:**

```python
# NOTE: AskUserQuestion caps each question at 4 options (CC schema: minItems 2,
# maxItems 4). Use plain `label` + `description` only — the schema permits a
# `preview` field, but on current CC it forces a side-by-side picker layout with
# dead up/down keyboard nav (confirmed 2026-05-28), so skills no longer use it
# (`markdown` was never valid). The 6 legacy
# modes are split across 3 valid questions: Q1 = exploration flow, Q2 folds the
# old "Constrained design" mode into constraints, Q3 carries the orthogonal
# "Plan first" preamble (it composes with any Q1 mode — it was never mutually
# exclusive). "Quick ideation" + STEP 0c /effort=low overlap; both downscale.
AskUserQuestion(
  questions=[
    {
      "question": "What type of design exploration?",
      "header": "Mode",
      "options": [
        {"label": "Open exploration (Recommended)", "description": "Generate 10+ ideas, evaluate all, synthesize top 3"},
        {"label": "Comparison", "description": "Compare 2-3 specific approaches I have in mind"},
        {"label": "Quick ideation", "description": "Generate ideas fast, skip deep evaluation"},
        {"label": "Iterative optimization", "description": "Try, measure, keep/discard, repeat (autoresearch-style)"}
      ],
      "multiSelect": false
    },
    {
      "question": "Any preferences or constraints?",
      "header": "Constraints",
      "options": [
        {"label": "None", "description": "Explore all possibilities"},
        {"label": "Use existing patterns", "description": "Prefer patterns already in codebase"},
        {"label": "Minimize complexity", "description": "Favor simpler solutions"},
        {"label": "Fixed requirements (constrained)", "description": "Hard requirements to work within — skip divergent phase, focus on feasibility (old 'Constrained design' mode)"}
      ],
      "multiSelect": false
    },
    {
      "question": "Research before ideating?",
      "header": "Plan-first",
      "options": [
        {"label": "No — dive straight in (Recommended)", "description": "Go directly to ideation"},
        {"label": "Yes — plan first", "description": "Read-only research (EnterPlanMode): scan codebase, map the solution space, then ExitPlanMode for approval before Phase 1 (old 'Plan first' mode)"}
      ],
      "multiSelect": false
    }
  ]
)
```

**If Q3 = 'Yes — plan first' (composes with any Q1 mode):**

```python
# 1. Enter read-only plan mode
EnterPlanMode("Brainstorm exploration: $TOPIC")

# 2. Research phase — Read/Grep/Glob ONLY, no Write/Edit
#    - Scan existing codebase for related patterns
#    - Search for prior decisions on this topic (memory graph)
#    - Identify constraints, dependencies, and trade-offs

# 3. Produce structured exploration plan:
#    - Key questions to answer
#    - Dimensions to explore
#    - Agents to spawn and their focus areas
#    - Evaluation criteria

# 4. Exit plan mode — returns plan for user approval
ExitPlanMode()

# 5. User reviews. If approved → continue to Phase 1 with plan as input.
```

**Based on answers, adjust workflow:**
- **Open exploration** (Q1): Full 7-phase process with all agents
- **Comparison** (Q1): Skip ideation (skips Phase 2), jump to evaluation phase
- **Quick ideation** (Q1): Generate ideas, skip deep evaluation
- **Iterative optimization** (Q1): Skip phases 2-6 (no Phase 2 fan-out), enter autoresearch-style loop (see below)
- **Constrained design** (Q2 = "Fixed requirements"): Skip divergent phase (skips Phase 2), focus on feasibility within the stated requirements, composes with any Q1 mode

**If 'Iterative optimization' selected:** skip Phases 2-6 and enter the autoresearch-style metric-driven loop.

Full sub-flow (metric question, baseline, loop body): `Read("references/iterative-optimization-mode.md")`

---

## STEP 0b: Select Orchestration Mode (skip for Tier 1-2)

Choose the **Workflow** call (star, scripted), **Agent Teams** (mesh, agents debate and challenge ideas) or the **Agent tool** (star, all report to lead):

1. Workflow mode → `workflows/brainstorm-diverge.js` runs the Phase 2 generators at effort `low` (STEP 0c)
2. Agent Teams mode → **recommended for 3+ agents** (real-time debate produces better ideas)
3. Agent tool mode → **for quick ideation**
4. `ORCHESTKIT_FORCE_TASK_TOOL=1` → **Agent tool** (override)

| Aspect | Agent Tool | Agent Teams |
|--------|-----------|-------------|
| Idea generation | Each agent generates independently | Agents riff on each other's ideas |
| Devil's advocate | Lead challenges after all complete | Agents challenge each other in real-time |
| Cost | ~150K tokens | ~400K tokens |
| Best for | Quick ideation, constrained design | Open exploration, deep evaluation |

> **Fallback:** If Agent Teams encounters issues, fall back to Agent tool for remaining phases.

---

## STEP 0c: Effort-Aware Phase Scaling

Read the `/effort` setting and scale brainstorm depth — `low` runs phases 0/2/5 only, `high` (default) runs all 7, `xhigh` adds extra devil's-advocate and synthesis rounds. Explicit user choice in STEP 0a always overrides downscaling.

Full level table + detection rules: `Read("references/effort-scaling.md")`

**Phase 2 always runs at effort `low`**, whatever the level above: in-the-loop ideation is where low effort pays, scoring is not. The skill has no `effort:` frontmatter on purpose (it would lower Phase 4 too); `workflows/brainstorm-diverge.js` passes `effort: "low"` to every generator instead. Details in the same reference.

**Fan-out rule:** a single pass is never a fallback when the selected mode runs Phase 2. Phase 2 runs through the Workflow call, Agent Teams, or the Agent tool; this skill runs inline (#4696) because a fork has no Workflow tool. If none of them spawns a generator, end the run as BLOCKED and say why. A mode that skips Phase 2 (Comparison, Iterative optimization, Constrained design) is not a violation.

---

**Finish line.** Done means: the top approaches are scored on all seven dimensions and the trade-offs are presented for the user to choose. Follow `Read("../../shared/rules/long-run-protocol.md")`: keep going when a step needs no input from the user, stop and ask only when you can't continue without them or before anything destructive, check each subagent's evidence before accepting it, and mark anything you couldn't confirm with where you looked.

## 🚨 CRITICAL: Task Management is MANDATORY

```python
# 1. Create main task IMMEDIATELY
TaskCreate(
  subject="Brainstorm: {topic}",
  description="Design exploration with parallel agent research",
  activeForm="Brainstorming {topic}"
)

# 2. Create subtasks for each phase
TaskCreate(subject="Analyze topic and select agents", activeForm="Analyzing topic")          # id=2
TaskCreate(subject="Search memory for past decisions", activeForm="Searching knowledge graph") # id=3
TaskCreate(subject="Generate divergent ideas (10+)", activeForm="Generating ideas")          # id=4
TaskCreate(subject="Feasibility fast-check", activeForm="Checking feasibility")              # id=5
TaskCreate(subject="Evaluate with devil's advocate", activeForm="Evaluating ideas")          # id=6
TaskCreate(subject="Synthesize top approaches", activeForm="Synthesizing approaches")        # id=7
TaskCreate(subject="Present design options", activeForm="Presenting options")                # id=8

# 3. Set dependencies (sequential chain: 2→3→4→5→6→7→8)
for i in range(3, 9):
    TaskUpdate(taskId=str(i), addBlockedBy=[str(i-1)])

# 4. Update status as you progress
TaskUpdate(taskId="2", status="in_progress")  # When starting
TaskUpdate(taskId="2", status="completed")    # When done — repeat for each subtask
```

---

## 🔄 The Seven-Phase Process

| Phase | Activities | Output |
|-------|------------|--------|
| **0. Topic Analysis** | Classify keywords, select 3-5 agents | Agent list |
| **1. Memory + Context** | Search graph, check codebase, read experiment journal | Prior patterns |
| **2. Divergent Exploration** | Generate 10+ ideas WITHOUT filtering | Idea pool |
| **3. Keep/Discard Gate** | Binary viability: keep, discard, or crash (10s per idea) | Survivors only |
| **4. Evaluation & Rating** | Rate 0-10 (7 dimensions incl. **simplicity**), devil's advocate | Ranked ideas |
| **5. Synthesis** | Filter to top 2-3, trade-off table, **test strategy per approach** | Options |
| **6. Design Presentation** | Present in 200-300 word sections, log to experiment journal | Validated design |
| **6.4. Living Plan Playground** (optional, on request or multi-wave plan) | Emit an updatable LPP playground via `visualize-plan`'s living-plan path | `<slug>.html` (living) |
| **6.5. Audio Podcast** (signal-fired, optional) | Auto-emit `brainstorm-podcast.m4a` when composite≥8.0 + approaches≥4 | `.m4a` file |

### Phase 6.4 — Living Plan Playground (optional)

When the user asked for a playground output, OR the synthesis produced a **multi-wave plan** (2+
execution waves with verifiable items), emit the design as a **living plan playground** instead of a
one-shot render: waves from Phase 5 synthesis, 7-dimension scores from Phase 4, discarded ideas with
reasons from Phase 3, one item per work unit with a "done when" evidence check. Route through
`visualize-plan`'s living-plan path (exemplar `living-plan.template.html`, update-mode contract in its
`visualize-plan/references/format-dispatch.md` §Living-plan update mode). The artifact then tracks its own execution:
later sessions flip item statuses in the embedded `lpp-state` JSON and append to its changelog — one
plan = one file, never fork.

### Phase 6.5 — Post-synthesis audio podcast (signal-fired, optional)

After Phase 6 lands, optionally invoke `scripts/post_synth_podcast.py <session-dir>` to auto-emit an audio podcast summarizing the top approaches + trade-offs. Self-skips on every non-happy-path so it never breaks the brainstorm:

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/post_synth_podcast.py "$CLAUDE_JOB_DIR"
```

Auto-skip conditions (all exit 0, all WARN-logged):

| Skip reason | Trigger |
|-------------|---------|
| `signal absent` | `composite[recommended] < 8.0` OR `len(approaches) < 4` |
| `design-doc.md not found` | Phase 6 didn't write a design doc to the session dir |
| `yg-mcp-core not importable` | `yg-mcp-core>=0.3.0` not installed (orchestkit is public; yg-mcp-core lives on private `pypi.yonyon.ai` — HQ-only) |
| `hq-content MCP unreachable` | MCP server down OR `.mcp.json` doesn't define `hq-content` |

Session dir must contain `brainstorm-output.json` (with `recommended`, `composite`, `approaches`) + `design-doc.md`. Handoff JSON at `<session-dir>/brainstorm-podcast.json` records `status` (`fired` / `skipped`) and `m4a_path` on success.

Mirrors `Yonatan-HQ/hq-ext-plugin#194` (audio_podcast handler for `/hq-ext:decide`).

### Progressive Output

Output results **incrementally** after each phase — don't batch everything until the end:

| After Phase | Show User |
|-------------|-----------|
| 0. Topic Analysis | Selected agents, tier classification |
| 1. Memory + Context | Prior decisions, relevant patterns, experiment journal summary |
| 2. Divergent Exploration | Each agent's ideas as they return (don't wait for all) |
| 3. Keep/Discard Gate | Survivors and discard reasons (keep/discard/crash per idea) |
| 4. Evaluation | Top-rated ideas with 7-dimension scores |

For Phase 2 parallel agents, output each agent's ideas **as soon as it returns** — don't wait for all agents. This lets users see early ideas and redirect the exploration if needed. Showing ideas incrementally also helps users build a mental model of the solution space faster than a final dump.

Load the phase workflow for detailed instructions:
```
Read("references/phase-workflow.md")
```

---

## ⚠️ When NOT to Use

Skip brainstorming when:
- Requirements are crystal clear and specific
- Only one obvious approach exists
- User has already designed the solution
- Time-sensitive bug fix or urgent issue

---

## Quick Reference: Agent Selection

| Topic Example | Agents to Spawn |
|---------------|-----------------|
| "brainstorm API for users" | workflow-architect, backend-system-architect, security-auditor, **test-generator** |
| "brainstorm dashboard UI" | workflow-architect, frontend-ui-developer, **test-generator** |
| "brainstorm RAG pipeline" | workflow-architect, llm-integrator, data-pipeline-engineer, **test-generator** |
| "brainstorm caching strategy" | workflow-architect, backend-system-architect, frontend-performance-engineer, **test-generator** |
| "brainstorm design system" | workflow-architect, frontend-ui-developer, design-context-extractor, component-curator, **test-generator** |
| "brainstorm event sourcing" | workflow-architect, event-driven-architect, backend-system-architect, **test-generator** |
| "brainstorm pricing strategy" | workflow-architect, product-strategist, web-research-analyst, **test-generator** |
| "brainstorm deploy pipeline" | workflow-architect, infrastructure-architect, ci-cd-engineer, **test-generator** |

**Always include:** `workflow-architect` for system design perspective, `test-generator` for testability assessment.

---

## Agent Teams Alternative: Brainstorming Team

In Agent Teams mode, form a brainstorming team where agents debate ideas in real-time. Dynamically select teammates based on topic analysis (Phase 0):

```python
# One implicit team per session: no TeamCreate and no team_name.
# Spawn teammates directly via Agent(name=...). Agent Teams needs
# CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in the user's environment.

# Always include the system design lead
Agent(subagent_type="ork:workflow-architect", name="system-designer",
     prompt="""You are the system design lead for brainstorming: {topic}
     DIVERGENT MODE: Generate 3-4 architectural approaches.
     When other teammates share ideas, build on them or propose alternatives.
     Challenge ideas that seem over-engineered — advocate for simplicity.
     After divergent phase, help synthesize the top approaches.""")

# Domain-specific teammates (select 2-3 based on topic keywords)
Agent(subagent_type="ork:backend-system-architect", name="backend-thinker",
     prompt="""Brainstorm backend approaches for: {topic}
     DIVERGENT MODE: Generate 3-4 backend-specific ideas.
     When system-designer shares architectural ideas, propose concrete API designs.
     Challenge ideas from other teammates with implementation reality checks.
     Play devil's advocate on complexity vs simplicity trade-offs.""")

Agent(subagent_type="ork:frontend-ui-developer", name="frontend-thinker",
     prompt="""Brainstorm frontend approaches for: {topic}
     DIVERGENT MODE: Generate 3-4 UI/UX ideas.
     When backend-thinker proposes APIs, suggest frontend patterns that match.
     Challenge backend proposals that create poor user experiences.
     Advocate for progressive disclosure and accessibility.""")

# Always include: testability assessor
Agent(subagent_type="ork:test-generator", name="testability-assessor",
     prompt="""Assess testability for each brainstormed approach: {topic}
     For every idea shared by teammates, evaluate:
     - Can core logic be unit tested without external services?
     - What's the mock/stub surface area?
     - Can it be integration-tested with docker-compose/testcontainers?
     Score testability 0-10 per the evaluation rubric.
     Challenge designs that score below 5 on testability.
     Propose test strategies for the top approaches in synthesis phase.""")

# Optional: Add security-auditor, llm-integrator based on topic
```

**Key advantage:** Agents riff on each other's ideas and play devil's advocate in real-time, rather than generating ideas in isolation.

**Fork pattern (CC 2.1.89 #1227; explicit since CC 2.1.232):** All brainstorm agents are fork-eligible: prompts are <500 words, no custom model, no worktree. CC shares the parent's cached API prefix across forks, reducing cost by ~60%. Do NOT add `model=` to agent calls. Since CC 2.1.232 forking is on by default and `subagent_type: "fork"` selects it explicitly, so the eligibility conditions matter only for ordinary `Agent()` calls. See `chain-patterns/references/fork-pattern.md`.

> **Nested delegation (CC 2.1.172+):** Teammates MAY be instructed to delegate a bounded sub-question to their declared sub-agents (e.g. backend-thinker → database-engineer to sanity-check a schema idea) instead of guessing inline. Keep chains ≤ 3 levels deep; divergent ideation itself stays flat — the parallel teammates above ARE the fan-out for independent ideas. See chain-patterns Pattern 9 (CC 2.1.172+).

**Team teardown** after synthesis:
```python
# After Phase 5 synthesis and design presentation
# CC 2.1.178+: no TeamDelete — teammates wind down at turn end
# (press Ctrl+F twice to stop lingering background teammates).

# Worktree cleanup (CC 2.1.72) — for Tier 3+ projects that entered a worktree
# If EnterWorktree was called during brainstorm (e.g., Plan first → worktree), exit it
ExitWorktree(action="keep")  # Keep branch for follow-up implement
```

> **Fallback:** If team formation fails, load `Read("references/phase-workflow.md")` and use standard Phase 2 Task spawns.

> **Session notes:** partial results from killed or turn-limited agents, cross-session replies, PostCompact recovery, recap, push notifications, manual cleanup, and teammate background tasks live in `references/claude-code.md` (section "Session notes moved from SKILL.md"). Read it when a brainstorm runs long or a teammate stops early.

---

## Key Principles

| Principle | Application |
|-----------|-------------|
| **Dynamic agent selection** | Select agents based on topic keywords |
| **Parallel research** | Launch 3-5 agents in ONE message |
| **Memory-first** | Check graph for past decisions before research |
| **Divergent-first** | Generate 10+ ideas BEFORE filtering |
| **Task tracking** | Use TaskCreate/TaskUpdate for progress visibility |
| **YAGNI ruthlessly** | Remove unnecessary complexity |

---

## Running unattended with /goal

Set a completion condition with `/goal` and this skill will keep working across turns until the condition is met. Works in interactive, `-p`, and Remote Control. The overlay panel shows live elapsed / turns / tokens.

**Example completion condition for this skill:**

```
/goal until design.options_count >= 2 AND user_chose_option, or stop after 8 turns
```

Stops when: 2+ ranked design options presented and the user selects one (or after Phase 6 if running unattended via -p). Compatible with claude.ai Remote Control runs.

---

## Quality Bar

Done means all of these hold:
- Phase 2 produced >=10 distinct ideas BEFORE any filtering, each surfaced as its agent returned
- Every idea past the keep/discard gate carries a one-line keep/discard/crash verdict
- Each surviving idea scores 0-10 on all 7 dimensions (simplicity included) plus one devil's-advocate challenge
- Synthesis narrows to 2-3 approaches with a trade-off table AND a per-approach test strategy
- Output ends with ranked options the user chooses from (or Phase 6 completes when running unattended via -p)

## 📜 Related Skills

- `ork:architecture-decision-record` - Document key decisions made during brainstorming
- `ork:implement` - Execute the implementation plan after brainstorming completes
- `ork:explore` - Deep codebase exploration to understand existing patterns
- `ork:assess` - Rate quality 0-10 with dimension breakdown
- `ork:design-to-code` - Convert brainstormed UI designs into components
- `ork:component-search` - Find existing components before building new ones
- `ork:competitive-analysis` - Porter's Five Forces, SWOT for product brainstorms

## Picker fallback (#1795)

The picker stall reported in orchestkit#1795 was a **schema break, not a CC input bug**: questions with >4 options or a `markdown` field (the `markdown` key is not valid — the schema field is `preview`) fail `AskUserQuestion` validation, so the picker never renders. All skill questions conform to the schema (2–4 options, no `preview` on multiSelect), enforced by `tests/skills/structure/test-askuserquestion-schema.sh`. Separately, although the schema *permits* a `preview` field, current CC renders any question that uses one in a side-by-side picker layout where ↑/↓ keyboard navigation is dead (confirmed 2026-05-28). So skills now standardize on plain `label` + `description` only and no longer set `preview`. If you still hit a stall on a future CC build, `ORK_ASK_FALLBACK=text` remains as a defensive opt-in: the `lifecycle/ask-fallback-injector` hook then tells the assistant to pose options inline as a numbered list. Hook propagates globally — no per-skill edit needed.

## References

Load on demand with `Read("references/<file>")`:

| File | Content |
|------|---------|
| `phase-workflow.md` | Detailed 7-phase instructions |
| `divergent-techniques.md` | SCAMPER, Mind Mapping, etc. |
| `evaluation-rubric.md` | 0-10 scoring criteria |
| `devils-advocate-prompts.md` | Challenge templates |
| `socratic-questions.md` | Requirements discovery |
| `common-pitfalls.md` | Mistakes to avoid |
| `example-session-dashboard.md` | Complete example |
| `mcp-probe-resume.md` | STEP -1 probe + resume + handoff-file table |
| `iterative-optimization-mode.md` | Autoresearch-style metric loop sub-flow |
| `effort-scaling.md` | `/effort` levels and phase scaling rules |

© OrchestKit · MIT · yonatangross/orchestkit

Похожие скиллы

Все скиллы по теме «Настройка агента: память, контекст, субагенты» →

Сначала — brainstorm от других авторов.

brainstorm Donchitos Скилл brainstorm ведёт от пустой головы или сырой идеи до одностраничного брифа игры в design/game-brief.md. Полезен на старте проекта и на гейм-джемах. CX Codex +1 831установок brainstorm NeoLabHQ Скилл brainstorm превращает сырую идею в структурированное техническое описание через серию уточняющих вопросов. Помогает до начала написания кода выбрать архитектуру и разобрать альтернативы. CX Codex +1 1 400установок brainstorm buiducnhat Скилл brainstorm помогает разобрать сложную или неясную задачу через диалог до написания кода. Скилл задаёт вопросы, оценивает варианты архитектуры и готовит дизайн-документ. CX Codex +1 628установок brainstorm hyperb1iss Скилл brainstorm для Claude Code помогает исследовать открытые вопросы о продукте или архитектуре. Он сравнивает варианты и предлагает проверку до реализации. CX Codex +1 615установок brainstorm johnlindquist Скилл brainstorm для Claude Code генерирует и развивает идеи, разбирает варианты и оценивает их по заданным критериям. Помогает проектировать функции и архитектуру, искать название. CX Codex +1 293установок oma-brainstorm First Fluke Скилл oma-brainstorm для Claude Code исследует замысел, ограничения и варианты решения до планирования или разработки. Уточняет неясную идею. CX Codex +1 ★ 1 472звёзд репо ce-brainstorm EveryInc Скилл ce-brainstorm превращает размытые идеи в структурированный план требований через диалог. Отделяет продуктовые решения от кода. CX Codex +1 4 200установок obsidian-brainstorm Eugeniu Ghelbur Команда obsidian-brainstorm для многоходового интервью об идее: агент задаёт вопросы по одному, пока идея не сойдётся, потом пишет дизайн-ноту с вариантами и рекомендацией. Подходит, если нужно продумать концепцию вместе, а не одним ударом. CX Codex +1 ★ 5 412звёзд репо bmad-brainstorm aj-geddes Скилл bmad-brainstorm запускает структурированные мозговые штурмы по методикам вроде SCAMPER, SWOT и «5 почему». Формирует отчёт с выводами для дальнейшего планирования. CX Codex +1 130установок brainstorm-ideas-existing phuryn Скилл brainstorm-ideas-existing для Claude Code: мозговой штурм идей существующего продукта с позиций PM, дизайнера и инженера. Генерирует фичи, прорабатывает возможности и поддерживает формат product trio. CX Codex +1 3 300установок upfront-design prathamdby Скилл upfront-design для Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI и OpenCode ведёт структурированное проектирование до написания кода. CX Codex +1 321установок

Из того же набора86

Весь набор →
documentation-patterns Скилл documentation-patterns для Codex даёт шаблоны README, ADR, OpenAPI-документации и changelog. Помогает оформлять документацию проекта и записывать архитектурные решения. CX Codex +1 150установок okr-design Скилл okr-design для Claude Code помогает ставить цели и выбирать метрики успеха. Он подключается при работе с OKR, KPI и дизайном экспериментов. CX Codex +1 140установок figma-design-handoff Скилл figma-design-handoff для Claude Code помогает переносить макеты Figma в код и описывать компоненты. Включается при подготовке дизайн-токенов, разборе Dev Mode или сравнении интерфейса с макетом. CX Codex +1 136установок user-research Скилл user-research для структурированного исследования пользователей: персоны, карты пути, интервью, тестирование юзабилити и card sorting. Помогает понять, что нужно пользователям, и обоснованно проектировать продукт. CX Codex +1 134установок setup Скилл setup сканирует проект, определяет стек, советует скиллы и MCP-серверы, а затем считает готовность проекта. Есть режимы повторного сканирования и настройки. CX Codex +1 133установок testing-integration Скилл testing-integration помогает проверять границы API и сервисов: интеграционные тесты, контракты Pact и валидацию схем Zod. Включается при работе с тестами API или взаимодействием сервисов. CX Codex +1 131установок testing-llm Скилл testing-llm помогает тестировать функции с языковыми моделями: подменять ответы, оценивать качество RAG и проверять структурированный вывод. Включается при разработке тестов для ИИ-функций. CX Codex +1 126установок prioritization Скилл prioritization для ранжирования задач бэклога методами RICE, WSJF, ICE, MoSCoW и анализом альтернативных издержек. Агент подсчитывает баллы, строит сравнительные таблицы и обосновывает выбор между конкурирующими фичами. CX Codex +1 125установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой