Skip to content
Skills Library
Programming · Planning

ideate

/ideate

Collaborative design exploration that authors the Design & Rationale section of the one unified docs/specs/ spec. Triggers: 'brainstorm', 'ideate', 'explore options', or /ideate. Default is a one-pass design preamble; the deep rung gates the 2-3 approach divergent loop and the discover bridge. Do NOT use for task decomposition (that is /plan, which adds Decomposition to the same doc) or code review.

Repository
exarchos ↗
Licence
Apache-2.0
Last repository change
24.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Collaborative design exploration that authors the Design & Rationale section of the one unified docs/specs/ spec. Triggers: 'brainstorm', 'ideate', 'explore options', or /ideate. Default is a one-pass design preamble; the deep rung gates the 2-3 approach divergent loop and the discover bridge. Do NOT use for task decomposition (that is /plan, which adds Decomposition to the same doc) or code review.

Triggers from the description

brainstormideateexplore options
Original author description

Collaborative design exploration that authors the Design & Rationale section of the one unified docs/specs/ spec. Triggers: 'brainstorm', 'ideate', 'explore options', or /ideate. Default is a one-pass design preamble; the deep rung gates the 2-3 approach divergent loop and the discover bridge. Do NOT use for task decomposition (that is /plan, which adds Decomposition to the same doc) or code review.

How it works

  1. Overview
  2. Triggers
  3. Planning depth (one-pass by default; deep gates the divergent loop)
  4. Process
  5. Iteration Limits
  6. Anti-Patterns
  7. State Management
  8. Completion & Coverage
  9. Transition
  10. Exarchos Integration
Original SKILL.md headings · 164 lines, 1,357 words
SKILL.md preview
---
name: ideate
description: "Collaborative design exploration that authors the Design & Rationale section of the one unified docs/specs/ spec. Triggers: 'brainstorm', 'ideate', 'explore options', or /ideate. Default is a one-pass design preamble; the deep rung gates the 2-3 approach divergent loop and the discover bridge. Do NOT use for task decomposition (that is /plan, which adds Decomposition to the same doc) or code review."
metadata:
  author: exarchos
  version: 2.0.0
  mcp-server: exarchos
  category: workflow
  phase-affinity: plan
---

# Brainstorming Skill

## Overview

Collaborative design exploration for new features, architecture decisions, and complex problem-solving. In the collapsed flow, there is **no separate design phase** — `{{COMMAND_PREFIX}}ideate` authors the `## Design & Rationale` section of **one unified `docs/specs/` artifact**, then auto-chains to `{{COMMAND_PREFIX}}plan`, which adds the `## Decomposition` section to the **same** document. The single approval point is `plan-review` (a dispatched, fresh-context adversarial pass over the unified doc).

The artifact shape is owned by the unified spec template — author against it, do not restate it: see `@skills/plan/references/spec-template.md`.

## Triggers

Activate this skill when:
- User says "let's brainstorm", "let's ideate", or "let's explore"
- User runs `{{COMMAND_PREFIX}}ideate` command
- User wants to discuss design rationale before decomposition
- A problem has multiple valid solutions needing evaluation (the `deep` rung)

For a complete worked example, see `references/worked-example.md`.

## Planning depth (one-pass by default; `deep` gates the divergent loop)

The design section is authored at one of three depths, resolved-then-frozen per feature as `designDepth` on PLAN entry (the per-feature analog of per-task `riskTier`). The resolver **proposes** a depth from brief signals (uncertainty, blast-radius, task count); the author confirms or overrides. A higher rung is a strict superset of the lower.

| `designDepth` | This skill's behavior | When |
|---|---|---|
| `thin` | One-pass: Problem Statement + the DR-N list. No alternatives, no exploration. | Trivial, low-blast features where the decomposition is the substance. |
| `standard` | One-pass: full rationale (Problem, Chosen Approach, DR-N with acceptance criteria, Technical Design, Alternatives). **(default)** | Most features. |
| `deep` | The divergent loop below: 2-3 genuinely distinct approaches with honest trade-offs and human back-and-forth, **plus** the opt-in discover bridge. | High-uncertainty / high-blast-radius features where the open-design path is warranted. |

**The 2-3 approach exploration is the `deep` rung — not a default ceremony.** At `thin`/`standard`, converge in one pass; do not manufacture alternatives the problem does not warrant.

## Process

### Phase 0: Constraint anchoring (first turn, before Phase 1)

**Goal:** Surface the architectural invariants relevant to the proposal *before* the clarifying questions, so the design is anchored to load-bearing constraints from the first turn.

Load the **core** invariants catalog at `.exarchos/invariants.md` (entries marked `cost-of-load: always-load`) and surface a **Constraints** section naming the relevant invariants — e.g. a CLI / agent-first surface proposal anchors on `INV-5a` (input ergonomics) and `INV-5c` (Aspire verbs). The full selection rules — `always-load` baseline vs `reference-only` on-demand vs `archivable` not-surfaced, the proposal-shape → anchor-invariant table, the emit format, and the catalog-registration gating (surfaced only when a catalog is registered under `invariants.catalogs`) — are the **single shared source of truth** for the design-time Constraints step used by `/ideate`, `/refactor`, and `/debug`. See `@skills/ideate/references/constraint-anchoring.md`.

Emit the **Constraints** section (per that reference) *before* Phase 1 so the clarifying questions can probe the proposal against the load-bearing invariants instead of re-discovering them mid-design.

### Phase 1: Understanding

**Goal:** Deeply understand the problem before proposing a design.

**Rules:**
- Ask ONE question at a time
- Wait for response before asking next question
- Focus on: goals, constraints, existing patterns, user preferences
- Maximum 5 questions before moving on

**Question Types:**
1. "What problem are we solving?" (core need)
2. "What constraints exist?" (time, tech, compatibility)
3. "What patterns already exist in the codebase?" (consistency)
4. "Who/what will consume this?" (users, APIs, other systems)
5. "What does success look like?" (acceptance criteria)

### Phase 2: Exploration — `deep` rung only

**Goal (when `designDepth: 'deep'`):** Present 2-3 distinct approaches with honest trade-offs, recommend one, and converge through human back-and-forth.

Use the approach format from `references/design-template.md`. Present genuinely different approaches; recommend one with rationale. **Opt-in discover bridge:** at the `deep` rung the runtime publishes a discover-bridge affordance via `next_actions` (DR-7) — an event-linked, `correlationId`-stitched escalation to the `{{COMMAND_PREFIX}}discover` research workflow. It **never** auto-runs; surface it to the author and only escalate on confirmation. Cite the discover report by path and `correlationId` in the Exploration section so provenance spans both documents.

At `thin`/`standard`, skip this phase — converge directly in Phase 3.

### Phase 3: Author the Design & Rationale section

**Goal:** Write the `## Design & Rationale` section of the unified `docs/specs/` artifact, at the resolved depth, using the structure in `@skills/plan/references/spec-template.md`. Sections of 200-300 words max; diagrams for complex flows.

**Requirements format (MANDATORY):**
- Use numbered requirement identifiers: `DR-1`, `DR-2`, ..., `DR-N`, under the `### Requirements (DR-N)` heading
- Each requirement MUST have an `**Acceptance criteria:**` block with concrete, testable criteria (`thin` may use a single bullet)
- At least one requirement MUST address error handling, failure modes, or edge cases
- These DR-N identifiers are provenance anchors — the `## Decomposition` section traces tasks to them **within this same document** (no second file)

**Save location:** `docs/specs/YYYY-MM-DD-<feature>.md`. Capture the path as `$SPEC_PATH`.

## Iteration Limits

**Design iterations: max 3** (the `deep` divergent loop). If Phase 2 cycles through 3 rounds without the user converging, pause and summarize the trade-offs for a final decision.

The user can override: `{{COMMAND_PREFIX}}ideate --max-iterations 5`

## Anti-Patterns

| Don't | Do Instead |
|-------|------------|
| Jump to a solution immediately | Ask clarifying questions first |
| Manufacture 2-3 options at thin/standard | Reserve the divergent loop for the `deep` rung |
| Hide drawbacks of the preferred option | Be transparent about trade-offs |
| Write walls of text | Use 200-300 word sections max |
| Ignore existing patterns | Reference codebase conventions |
| Write a separate `docs/designs/` doc | Author the Design & Rationale § of the one `docs/specs/` artifact |
| Auto-escalate to discover | Surface the bridge; escalate only on author confirmation |

## State Management

This skill manages workflow state for context persistence.

### On Start (before Phase 1)

Initialize workflow state using `{{MCP_PREFIX}}exarchos_workflow` with `action: "init"`, `workflowType: "feature"`, and the featureId. The feature workflow's **initial phase is `plan`** (the former ideate/GATHER phase was collapsed into PLAN) — there is no phase to transition into here.

### On Design-Section Save (after Phase 3)

Persist the unified-spec path as `artifacts.spec` (NOT `artifacts.design` — the new flow produces one `docs/specs/` artifact):

```text
action: "update", featureId: "<id>", updates: { "artifacts": { "spec": "<docs/specs/...>" } }
```

Do **not** transition the phase here — `{{COMMAND_PREFIX}}plan` finalizes the unified doc with the `## Decomposition` section and transitions `plan → plan-review`.

### Phase Transitions and Guards

This skill is the entry point for the **feature workflow** (`workflowType: "feature"`). The collapsed lifecycle is:

```text
plan → plan-review → delegate ⇄ review → synthesize → completed
```

`{{COMMAND_PREFIX}}ideate` and `{{COMMAND_PREFIX}}plan` both author the one `docs/specs/` artifact **within** the initial `plan` phase. For the full transition table, consult `@skills/checkpoint/references/phase-transitions.md`.

### Schema Discovery

Use `exarchos_workflow({ action: "describe", actions: ["update", "init"] })` for
parameter schemas and `exarchos_workflow({ action: "describe", playbook: "feature" })`
for phase transitions, guards, and playbook guidance.

## Completion & Coverage

There is **no separate design-completeness gate** in the collapsed flow — `check_design_completeness` is a deprecated alias. The design section's acceptance-criteria coverage is validated as part of `check_plan_coverage` over the unified artifact, run by `{{COMMAND_PREFIX}}plan` once the `## Decomposition` section exists. Before chaining, confirm each `DR-N` carries acceptance criteria and at least one DR-N covers error handling / edge cases.

## Transition

After the Design & Rationale section is authored, **auto-continue to decomposition** (no user confirmation):

### Pre-Chain Validation (MANDATORY)

Before invoking `{{COMMAND_PREFIX}}plan`:
1. Verify `artifacts.spec` exists in workflow state
2. Verify the spec file exists on disk: `test -f "$SPEC_PATH"`
3. If steps 1 or 2 fail: "Spec artifact not found, cannot auto-chain to {{COMMAND_PREFIX}}plan"

### Chain Steps

1. Update state: `action: "update", featureId: "<id>", updates: { "artifacts": { "spec": "<docs/specs/...>" } }`
2. Output: "Design & Rationale section saved to the unified spec. Auto-continuing to decomposition..."
3. Invoke immediately:
   ```typescript
   {{CHAIN next="plan" args="$SPEC_PATH"}}
   ```

This is NOT a human checkpoint. The single human checkpoint occurs at plan-review (the dispatched adversarial pass over the unified artifact) and at synthesize (merge confirmation).

**Workflow continues:** `{{COMMAND_PREFIX}}ideate` -> `{{COMMAND_PREFIX}}plan` -> plan-review -> [HUMAN CHECKPOINT] -> `{{COMMAND_PREFIX}}delegate` -> `{{COMMAND_PREFIX}}review` -> `{{COMMAND_PREFIX}}synthesize` -> [HUMAN CHECKPOINT]

## Exarchos Integration

When Exarchos MCP tools are available:

1. **At workflow start:** Auto-emitted by `exarchos_workflow` `action: "init"` — do NOT manually append `workflow.started`
Files in this package (4)
  • SKILL.md 10 KB
  • references/constraint-anchoring.md 4 KB
  • references/design-template.md 3 KB
  • references/worked-example.md 3 KB

Versions

RepositoryScoreLicence
This page · lvlup-sw/exarchos100Apache-2.0
mthines/agent-skills100MIT
liveloveapp/hashbrown100MIT
lvlup-sw/exarchos100Apache-2.0
lvlup-sw/exarchos100Apache-2.0
lvlup-sw/exarchos100Apache-2.0
av/skills100MIT
pg013c/pg-toolkit100MIT
howells/arc100MIT

Database snapshot: 13.11.2026 · package version 7c816b7cf568 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100plan
    Decompose the unified docs/specs/ artifact into parallelizable tasks — the ## Decomposition section of the same document whose ## Design & Rationale section holds the DR-N source. Triggers: 'plan implementation', 'create tasks from spec', or /plan. Applies the verification…
  • 100brainstorm
    Use before any creative work or significant changes. Activates on "brainstorm", "let's brainstorm", "deep analysis", "analyze this feature", "think through", "help me design", "explore options for", or when user asks for thorough analysis of changes, features, or architectural…
  • 100brainstorm
    Divergent-convergent brainstorming with research, ideation, and trade-off analysis. Use when exploring options, generating ideas, comparing approaches. Triggers include "brainstorm", "explore options", "ideate", "compare approaches".
  • 90close-spec
    When a spec under specs/<feature>/ is done shipping (a write-spec build, or any planned task that produced a spec), archive it to specs/done/ and rewrite it from a build-plan into a durable rationale — the why, the principles, the invariants — pointing back to the real code for…
  • 100spec-explore
    Spec-aware Explore → Plan → Implement for projects that maintain a specification system under specs/. A thinking partner for exploring ideas and clarifying requirements that grounds investigation in the project's specs/ before reaching for code, produces a roadmap (What / How /…
  • 100brainstorm
    Use this skill when exploring an open product or architecture question before choosing an approach. Activates on mentions of brainstorm, ideate, design session, explore options, what should we build, how should we approach, let's think about, new project, architecture decision,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.