Design Wide

---
name: design-wide
description: 'ADHD-internals variant of `sdd:design` — N=5 frame-reframed proposals diverged in isolated parallel sub-agents, then mechanically scored ∧ clustered; top-3 by score seed `## Proposal` as labeled alternatives A | B | C, Open Questions loop converges per sister design skill. Use when user wants wider divergence than single-pass propose-shape can supply, or names ADHD-mode explicitly. Triggers: "/sdd:design-wide", "design-wide <topic>", "ADHD design", "diverge wide on", "show me alternative shapes for", "give me N proposals for", "what else could this look like".'
allowed-tools: AskUserQuestion, Read, Grep, Write, Agent, Skill
---

# design-wide — ADHD diverge → focus → designs/<slug>.md draft

## AUDIENCE

Skill body ∈ SPEC-ADJACENT ∴ glyph register. Design file output (`designs/<slug>.md`) ≡ user-reviewing surface pre-spec-fold ∴ steno register (readable symbols `→ & | §`, ⊥ heavy math glyphs `∀ ∃ ∴ ⊥ ∈ ∉`). Encoding follows audience.

## Position vs sibling `design` skill

Output contract identical to `design`: writes `designs/<slug>.md` (steno), converges on `## Open Questions` ∅, design-file lifecycle managed by `/sdd:spec` fold-in (deletes draft post-apply per design-lifecycle invariant ∈ SPEC.md). Trigger surface separate (`/sdd:design-wide`).

Internals differ at step 2 only: where `design` proposes shape in 1 pass from user framing, `design-wide` mechanically diverges across N=5 vantage frames in isolation, then mechanically scores ∧ clusters → top-3 seeds `## Proposal` as A | B | C alternatives.

Both skills coexist pending A/B comparison; same fold-in path ∀ either output file.

## Loop

1. read `SPEC.md` ∈ root → degrade gracefully if absent
2. **diverge → focus** (per ADHD protocol below; replaces single-pass propose-shape)
3. surface `## Proposal` w/ A | B | C labeled alternatives + `## Open Questions` list at bottom
4. wait → user critique / answers / pick
5. update Proposal in place; resolved Qs → `## Design decisions` w/ rationale; user may narrow to one alternative ∨ keep all three pending convergence
6. repeat 4–5 until `## Open Questions` ∅
7. on confirm → write draft to `designs/<slug>.md` (steno-encoded per template)

∀ turn post-step-2: ⊥ self-resolve Open Questions. Resolution ⊢ user input.

## Step 2 — ADHD diverge-focus protocol

Three phases, 7 sub-agent calls total (5 diverge + 1 score + 1 cluster); user-accepted silently @ invocation time per read-class delegation invariant ∈ SPEC.md (writes serialize main-thread; reads delegable).

### Phase 2a — Frame selection

1. read `pilot-spec/skills/design-wide/frames.yaml` → frame library (entries tagged `systems` | `paradigm` | `role` | `meta`).
2. select 5 frames per default heuristic below (mechanical, ⊥ skip even if topic seems narrow).
3. emit selected frame names + vantages to user as 1-line each ∀ transparency (⊥ wait-state).

Default selection heuristic ∀ unfamiliar topic: 2 × `systems` + 1 × `paradigm` + 1 × `role` + 1 × `meta`. Operator may override via free-text @ invocation (e.g. `/sdd:design-wide --frames=speedrunner,inversion,...`); override path retired pending need.

### Phase 2b — Diverge (parallel, isolated)

Spawn 5 `general-purpose` Agent calls in a single response (parallel dispatch ∀ true isolation; sequential calls share no context but lose latency parallelism). ∀ call:

- Agent type: `general-purpose`
- System prompt: **Generator block** (canonical, copy verbatim — see below)
- User prompt: topic + selected frame vantage + SPEC.md context excerpt (∃ ?)
- Output: design proposal under that frame's vantage, structured per output schema

Branches share no context across calls ∴ anchoring mechanically prevented. Generator-only system prompt forbids evaluation / scoring / critique / "but I should mention" hedges.

#### Generator block (copy verbatim per branch — parameterized by `<frame.name>`, `<frame.vantage>`, `<topic>`, `<spec_excerpt>`)

```
You are a design generator operating under one specific vantage. Your only job is to propose a design shape for the topic from that vantage. You DO NOT evaluate, score, critique, compare alternatives, hedge, or mention what other vantages might say. Generate only.

Vantage: <frame.name>
Vantage prompt: <frame.vantage>

Language discipline: respond strictly in computer-science vocabulary. If
your vantage suggests an analogy from another discipline (biology,
economics, pedagogy, etc.), translate the analogy into CS primitives
(types, processes, queues, protocols, data structures, scheduling,
capabilities, state machines) *before* you state it. Do not output non-CS
metaphors verbatim. If a CS translation does not exist for the analogy,
drop the analogy.

Topic: <topic>

SPEC.md context (may be empty if no SPEC.md present):
<spec_excerpt>

Produce a proposal under this exact schema (no preamble, no trailing summary):

## Shape
[named structures, types, key decisions — propose-then-critique starting point]

## Mechanism
[how the shape works in one or two paragraphs — concrete moves, not abstract goals]

## Cost
[what this costs: complexity, latency, tokens, surface area, lock-in]

## Trap flag
[1 line: name the most likely failure mode of this proposal, or `none-obvious` if no clear trap]

Output the four sections above and stop. Do not add summary, comparison, or recommendation.
```

### Phase 2c — Focus (sequential, critic-only)

After all 5 branches return:

1. **Score** — 1 sub-agent call (`general-purpose`), critic-only system prompt.
2. **Cluster** — 1 sub-agent call (`general-purpose`), critic-only system prompt.

Both prompts copy verbatim per call (mechanical, ⊥ improvise).

#### Score block (copy verbatim)

```
You are a critic. Your only job is to score five design proposals against weighted criteria. You DO NOT generate new proposals, propose merged shapes, or write your own design. Score only.

Criteria and weights:
- Feasibility (0-5, weight 2): can this be built with the constraints in the SPEC.md excerpt?
- Spec fit (0-5, weight 2): does this respect the §V invariants and §C constraints?
- Cost discipline (0-5, weight 1): is the cost section honest and proportional?
- Surface area (0-5, weight 1): does this add or contain complexity?
- Risk-of-trap (0-5, weight 1, INVERTED — high score means LOW risk): how recoverable is the trap flag the generator named?

Output a pipe-table with one row per proposal, in the order received. Schema:

id|feasibility|spec_fit|cost|surface|risk_inv|weighted_total|trap_flag

`weighted_total` = 2*feasibility + 2*spec_fit + 1*cost + 1*surface + 1*risk_inv (max 35).

`trap_flag` is the verbatim trap-flag line from the generator (NOT your re-rating). If the generator wrote `none-obvious`, write `none-obvious`. If the generator named a trap that is itself disqualifying (e.g. "violates a §V invariant cited in SPEC.md excerpt"), append ` | TRAP` to the row.

Output only the pipe-table. No preamble, no trailing notes.
```

#### Cluster block (copy verbatim)

```
You are a critic. Your only job is to cluster five scored design proposals into 2-3 groups of similar shape and pick a single representative per group. You DO NOT generate new proposals or merge proposals into novel shapes. Cluster and select only.

Input: five proposals (full body) + a pipe-table of weighted scores including trap flags.

Procedure:
1. Drop any proposal whose row in the score table ends with `TRAP` — disqualified, not eligible for representation.
2. Group remaining proposals by structural similarity: same key named structure, same control flow, same persistence shape, etc. Aim for 2-3 clusters; identical-cluster collapse OK if proposals are near-duplicates.
3. For each cluster, pick the highest weighted_total proposal as the representative.
4. Take the top 3 representatives (by weighted_total) and label them A, B, C in descending score order. If fewer than 3 clusters survive trap filter, output only A and B (or just A) — do not fabricate.

Output schema (no preamble, no trailing summary):

## A — <one-line summary of the shape>
[verbatim Shape + Mechanism + Cost sections from the chosen proposal]

## B — <one-line summary of the shape>
[verbatim Shape + Mechanism + Cost sections from the chosen proposal]

## C — <one-line summary of the shape>
[verbatim Shape + Mechanism + Cost sections from the chosen proposal]

## Cluster notes
[1-3 lines: which proposals merged into which cluster, and which (if any) were trap-dropped]

Stop after Cluster notes. Do not synthesize a recommended choice.
```

### Phase 2d — Seed Proposal

Main thread copies the cluster output verbatim into the in-progress design draft under `## Proposal`; labels A | B | C preserved. Topic-specific sections (e.g. "Tool ownership", "Naming") deferred to Open Questions phase if alternatives differ on them.

## Distinction from sibling `design`

|skill|step-2 internals|cost|use when|
|design|single-pass propose-shape from user framing|1 main-thread pass|topic well-localized, user has shape-instinct|
|design-wide|N=5 frame diverge + score + cluster → A\|B\|C|7 sub-agent calls|topic open, user wants alternatives surfaced mechanically|

⊥ merge. Outputs interchangeable post-Phase-2; fold-in path same for both.

## Output template (design file body)

Identical to sibling `design` skill — steno register, same sections. Phase-2c cluster output replaces the single-pass `## Proposal` seed:

```
# <title>

## Problem

[symptoms + §B/§V citations if SPEC.md present, else "designing without SPEC anchor"]

## Proposal

### A — <one-line summary>
[Shape + Mechanism + Cost]

### B — <one-line summary>
[Shape + Mechanism + Cost]

### C — <one-line summary>
[Shape + Mechanism + Cost]

## [topic-specific sections, e.g. "Tool ownership", "Naming", "Layering"]

## Effect on in-flight SPEC items

[§T/§V deltas — what gets superseded, narrowed, unchanged. omit section if SPEC.md absent.]

## Design decisions

[each resolved Open Q + rationale, in `**Decision:** ... **Why:** ...` shape; record alternative-narrowing decisions here too — "**Decision:** A. **Why:** ..."]

## Success criterion

[observable invariants — "X cannot recur", "Y returns Z", measurable]

## Out of scope

[deferred → §T row ∨ future issue]

## Unresolved

[only if ≥3-turns/Q escape used — parked Qs for follow-up]
```

User may narrow to one alternative pre-persist (drops B, C from Proposal, records decision @ `## Design decisions`); skill ⊥ self-narrow.

## Code reads

Reactive only. ⊥ preemptive scans (parallel ∀ sister `design` skill).

- ⊥ allowed: grep repo before Phase 2 "to find context" — generators propose from user's framing + SPEC.md + frame vantage.
- ✓ allowed: user cites `file:line` ∨ symbol ∨ path → read that target. user claims behavior in code → spot-check before next critique turn.

Cap: ≤ 2 reads/turn @ main thread. Sub-agents in Phase 2b inherit cap ∈ generator block (read budget bounded by topic + spec excerpt + frame vantage).

## SPEC.md degradation

`SPEC.md` ∈ root absent → flag once: "designing without SPEC anchor; §V/§B/§T citations omitted; spec_excerpt field passed empty to generators". continue. omit `## Effect on in-flight SPEC items` from output.

## Long-session escape

single Open Q ≥ 3 turns w/o resolution → decision-gate per decision-gate invariant (mid-flow consequence-bearing prompt — selection drives persist-shape ∈ current turn) → emit AskUserQuestion call:

- **question**: `Park unresolved Q under '## Unresolved' ∧ converge on rest, or keep going?`
- **options** (2 — mutually exclusive):
  - `Park Q ∧ converge` — move Q to `## Unresolved`, proceed to convergence ∧ persist
  - `Keep going` — return to step 4 loop
- **header**: `Open-Q escape`
- prose `or keep going?` form ⊥ allowed — selection drives `## Unresolved` shape ∈ persisted draft.

Park ⇒ persisted draft carries explicit unresolved list ∈ `## Unresolved` section. ⊥ pretend resolved.

## Mode

Write-new-design-file only. ⊥ append-to-existing. Re-run for same topic w/o user narrowing → fresh diverge (frames may overlap by chance; ⊥ deduplicate, ⊥ re-use prior branches).

## Title ∧ slug

Draft body opens w/ `# <title>` heading. Slug derivation identical to sister `design` skill: short kebab-case, ≤ 5 words, ≤ 50 chars; collision → `-<n>` suffix.

Filename: `designs/<slug>.md`.

## Persist

1. ensure `designs/` dir exists @ repo root → create if missing.
2. derive slug per § above.
3. write design body (steno-encoded per template) to `designs/<slug>.md`.
4. show file path + summary to user.

⊥ commit. Caller may stage manually ∨ wait for `/sdd:spec` fold-in (deletes file as part of apply per design-lifecycle invariant ∈ SPEC.md).

## Convergence gate

Ready ⇔ `## Open Questions` ∅ ∧ user confirms.

⊥ persist w/o confirmation. ⊥ self-resolve Qs. ⊥ collapse multiple Qs into one to fake convergence. ⊥ persist multi-alternative Proposal (A|B|C) silently as "user chose later" — if alternatives unresolved @ convergence, fold the unresolved choice into `## Open Questions` ∨ park under `## Unresolved` via escape.

## Boundary

⊥ mutate `SPEC.md`. design-wide produces `designs/<slug>.md` draft only. SPEC amendment ⊢ caller runs `/sdd:spec <designs/<slug>.md>` after persist (gate routes to design-file fold-in per design-lifecycle invariant ∈ SPEC.md). Impl ⊢ `/sdd:build` after spec amended.

⊥ root-cause debugging — that's `/sdd:backprop`. design-wide = structural shape, ⊥ "why is this broken".

## Escape hatch

"just file it" ∨ "skip the design" ∨ "I already know what I want" → stop. Hand verbatim intent to `/gh:issue` (file as GitHub issue) ∨ `/sdd:spec` (amend SPEC directly w/o design draft).

"too many alternatives, just one" → recommend swap to `/sdd:design` (sister skill, single-pass propose-shape).

## OUTPUT — "Next" block

Heading `## Next`; 1–5 atomic items (one sentence each, no `Reply` prefix); positional dispatch (`run <int>` ∨ `run /<plugin>:<cmd> [args]`). Optional `## Hint` (≤ 3 lines) precedes when item selection needs hidden state (e.g. fold-in deletes `designs/<slug>.md` post-apply ∴ ⊥ archived draft, ∨ multi-alternative Proposal pending narrow). Mid-loop items lead w/ alternative-narrow ∨ Open-Q resolution; post-persist items lead w/ `/sdd:spec <designs/<slug>.md>` fold-in.

Example mid-loop with multi-alternative Proposal and Open Questions outstanding:

```
## Next

1. narrow to one alternative (A, B, or C) and answer the next Open Question
2. /sdd:design-wide park — move unresolved Q under `## Unresolved` and persist
3. /sdd:design rework — swap to single-pass sister skill if alternatives feel noisy
4. /gh:issue — file verbatim intent as an issue instead
```

Example after persist (terminal — `designs/<slug>.md` written):

```
## Next

1. /sdd:spec designs/<slug>.md — fold the draft into SPEC.md
2. /sdd:design-wide rework — iterate the draft before fold-in
3. /gh:issue — file the intent as an issue instead
```