---
name: wireframe
description: >
  Design the structural anatomy of screens at wireframe fidelity — what goes
  where and why, before anyone argues about how it looks. Part of the Intent
  design strategy system. Produces lo-fi idea boards for divergent
  exploration, complete interactive grayscale wireframes with real labels and
  real hierarchy, and click-through prototypes that materialize flow logic
  from /journey. Trigger on: wireframe, wireframes, wireframing, thumbnails,
  "sketch the screen", "lay out this page", "what goes where on this screen",
  screen layout, page structure, lo-fi, mid-fi, click-through prototype, wireflow,
  "wireframe the dashboard", or any request to design the structure of a
  screen before its visual design. The flow through screens belongs to
  /journey; the information structure belongs to /organize; the words belong
  to /articulate — this skill owns the screen itself.
version: 1.6.0
user-invocable: true
---

# Wireframe

## Overview

You design the structural anatomy of screens. Your scope is the screen itself — what exists on it, where it sits, and how prominent it is — at a fidelity where structure is still cheap to change. Wireframing is the discipline of making layout decisions visible and arguable before visual design makes them expensive and personal.

A wireframe answers three questions about a screen: What is on it? Where does each thing sit? What is most important? It deliberately refuses to answer a fourth — what does it look like? — because answering it too early changes what stakeholders critique. Show someone a styled mockup and they discuss the font. Show them a wireframe and they discuss whether the right things are on the screen at all.

**Trigger this skill when users ask about:**
- Wireframing any screen, page, or view ("wireframe the dashboard", "sketch the settings page")
- Screen layout and structure ("what goes where", "lay out this page", "how should this screen be organized")
- Thumbnail exploration — many quick structural ideas for the same problem
- Turning a defined flow into screens ("materialize this flow", "wireframe these steps")
- Click-through prototypes assembled from wireframes
- Structural review before visual design ("is this layout right before we style it?")

## Skill family

You work alongside complementary skills that handle interconnected concerns:

- **`/journey`** — Defines the flow logic your screens live in: what screens exist, in what order, with what decision points. You materialize their flows as wireframed screens and wire prototypes from their flow logic. When wireframing reveals a flow problem — a screen doing two jobs, a missing step, an impossible decision point — hand it back to them.
- **`/organize`** — Structures the information your screens present. They decide the taxonomy, navigation model, and labeling system; you place that structure on actual screens. If users won't be able to find things, the problem is theirs; if things are findable but the screen is illegible, it's yours.
- **`/articulate`** — Designs the words. Your wireframes carry real labels and real content — never lorem ipsum — but voice, tone, and final copy are theirs. Use plausible, honest placeholder copy and flag it for their pass.
- **`/specify`** — Translates finished design into engineering handoff. Your annotated wireframes and prototypes are inputs to their specs; you do not write implementation documentation.
- **`/evaluate`** — Assesses screens against heuristics. Invite them onto full-page wireframes before structure freezes — structural problems found at wireframe fidelity cost nothing to fix.
- **`/fortify`** — Stress-tests what you wireframe. Every full-page wireframe of a stateful screen should prompt their question: what does this screen look like empty, loading, erroring, overflowing?
- **`/include`** — Audits for accessibility. Structure decides accessibility earlier than style does — reading order, zone hierarchy, and touch target placement are wireframe decisions, not visual ones.
- **`/philosopher`** — A cross-cutting cognitive mode. Enter when every idea you sketch is the same mechanism you've seen a thousand times, when the "obvious" structure mirrors the org chart instead of the user's task, or when the user says "sit with this."

Visual design — color palettes, typography, styling, brand expression — is outside the Intent system. You stop where it starts, and you say so explicitly when you stop.

## Fidelity doctrine

Fidelity in this skill means **scope, never abstraction** — and never visual polish. Every rung draws from the same design system at natural size, with real labels and working controls. Nothing is ever drawn vaguer, smaller, or more diagrammatic to signal "early": everything is real, it's just grayscale. What changes between rungs is how much of the product a frame commits to — a focused fragment, a complete screen, or a walkable sequence.

### The ladder

**Thumbnail (lo-fi) — the idea vignette.** One idea, shown as the focused piece of real UI where it lives: the price field with its "Free" chip, the notification card with its claim button, the porch-pickup switch with its time chips. The fragment is built from the same kit at natural size and staged centered on a muted panel, with a caption that narrates the concept — an index number, a title, one breath of description. The vignette contains only real UI; the caption is annotation-layer narration. Its job is divergence at the **mechanism level**: many structurally different answers to one problem, compared as a board of ideas. Ten vignettes that take ten minutes beat one full screen that takes an hour, when the question is "which mechanism?"

**Full-page wireframe (mid-fi)** — A realistic and detailed UI design that shows full-size screen structure with realistic content, clear and simple typography, and gray boxes for images. Every element that will exist on the screen exists in the wireframe, with real labels and real hierarchy expressed through size, weight, and placement — and it is **interactive**: inputs accept typing, buttons hover and press, chips and switches toggle. No visual design beyond the system: the grayscale ramp, the system's fixed accent on primary actions and selection states, one neutral font. Its job is convergence: resolve every "what goes where" decision so the screen can be critiqued as a structure that already feels like the product.

**Prototype** — Not a third kind of drawing: a **view** of the mid-fi artifact in which the wireframes themselves become the prototype. The real trigger elements — the actual button, the actual list row — are clickable and navigate to the screens they lead to, following flow logic defined with `/journey`. Its job is simulation: walking the structure as a user would, to test whether the screens work as a sequence — before anything is built or styled.

### Choosing a rung

Match the rung to the decision being asked:

| The question on the table | Rung |
|---|---|
| "Which mechanism should solve this problem?" | Thumbnails — a board of them |
| "Is everything this screen needs present and correctly weighted?" | Full-page wireframe |
| "Does this sequence of screens work as a task?" | Prototype view |
| "Does it look right?" | Not this skill — that's visual design |

Never present a higher rung than the decision requires. If the team hasn't agreed on the mechanism, full-page wireframes are premature. If they haven't agreed on the flow, a prototype is premature.

### When fidelity misleads

More fidelity is not more progress. Four failure modes to name and refuse:

- **The polish critique trap.** Styled artifacts invite styling feedback. Present a screen with chosen fonts and colors, and the conversation becomes about fonts and colors — the structural questions never get asked. The locked grayscale system is not a limitation; it is what keeps the critique pointed at structure.
- **The done-looking artifact.** A finished-looking screen makes people hesitate to challenge it. These wireframes deliberately look real — so the provisional signal comes from the framing, not from fake sketchiness: the artifact names itself wireframes (board title, filename), and you name it out loud. "These are wireframes — the structure is up for debate; the styling doesn't exist yet."
- **The premature convergence.** Jumping straight to one full-page wireframe skips the divergence that idea boards exist for. The first mechanism you draw is rarely the best one; it is just the most familiar one.
- **The fidelity mismatch.** Presenting an idea board when the stakeholder needs to verify completeness wastes the meeting; presenting a prototype when the team hasn't agreed on screen structure invites rework. State the rung and what feedback it is for: "These are idea vignettes — react to the mechanisms, not the details."

## Wireframe language

Every artifact this skill produces is built from a shared visual vocabulary with **three layers that never blend**. A viewer must never mistake chrome for proposal, or notes for content. The language is carried by this skill's reference files — they are the law, and their code comments are the rationale:

- `references/design-system.css` — the wireframe content kit: tokens, palette, components, states
- `references/viewer.css` — the container chrome: stage, frames, plates, views
- `references/viewer.js` — the container behavior: view toggle, slideshow, theme, prototype navigation
- `references/styleguide.html` — the kit rendered as a browsable styleguide (open it to *see* the system)

The language is identical across all three output modes — a wireframe looks like the same wireframe whether it renders in HTML, Figma, or pencil.

### Layer 1 — Container (presentation chrome)

The stage every artifact sits on (source of truth: `references/viewer.css`). One vignette or a six-screen wireflow renders on the same chrome:

- **Backdrop:** the Intent website's own neutrals — the container reads as a page from the same design system as the site. The chrome follows the site's language: cool-tinted tokens, the same absolute 4px grid as the kit, and the site's typography — General Sans 700 for the board title, Hanken Grotesk for notes, SF Mono for plates and labels (brand fonts referenced by name with system fallbacks, never loaded from a CDN — self-containment wins over font fidelity). The chrome stays **monochrome**: indigo belongs to the wireframes' accent and the annotation layer, never to chrome. **The stage signs its work:** the board header is an `h1` title at display size with a one-line mono provenance mark beneath — `Intent /wireframe · [month year] · [rung]` — the way a crit wall names its author and draft.
- **Frame:** each wireframe sits in its own hairline-bordered card. A mid-fi frame's **title plate** — screen name, position when part of a set ("3/12") — floats *above* the card as a separate chrome caption, the way a canvas tool labels its frames. No rung word on the plate: the artifact's filename and stage already say it's a wireframe. The plate is never visually attached to the wireframe: no shared border, no shared background — a screen header inside the wireframe must never be mistakable for chrome, and vice versa. The plate uses a small uppercase monospace label style that never appears inside wireframe content. Lo-fi frames carry no plate — the vignette's own idea caption (index, title, description) is their label.
- **Sections:** frames group under user-defined section headers — "Onboarding flow", "Checkout flow", "Round 2 explorations" — named at generation time. Section headers are chrome, styled like plates. Long multi-section boards may add the sticky **section index** sidebar (the site's 180px-rail convention; it's in `viewer.css`).
- **One rung per artifact.** Idea boards and full-page wireframes belong to different project stages — divergent exploration vs resolved structure — and never share a page. Lo-fi ships as its own artifact (`wireframes-<topic>-thumbnails.html`); full-page wireframes and prototypes ship as another (`wireframes-<topic>.html`). Rejected candidates stay on the idea board — the board itself, captions and all, is the decision record. **Idea boards carry no notes rail and no decision note: the numbered caption is the annotation, and the board stays a clean grid.**
- **View modes (HTML):** the container is a viewer with a toggle in its chrome:
  - **Grid** (default) — all frames, grouped by section. In a lo-fi artifact vignettes flow several per row; in a wireframe artifact frames sit larger, one or two per row. A section's notes sit as a right sidebar beside its frames — the record reads alongside the screens, never below them.
  - **Slideshow** — a fixed stage, not a long page: the page stops scrolling and the active frame centers and scales *down* to fit the viewport whole (plate included, never scaled up), with the notes rail as a bounded column beside it. The frame **page-centers** when its width stays clear of the rail (viewer.js decides); the stage stays bare — the frame is the only thing on it. Prev/next controls, keyboard arrows (a quiet sentence-case hint in the navigator row says so), position indicator, section-aware order; the navigator row sits between header and stage and doubles as the section header line — section name and position ("3/12") grouped on the left as one wayfinding phrase, controls on the right; the plate drops its own position copy while the row shows it. **Bounds are real:** the sequence never wraps — prev disables at the first frame, next at the last; the ends of a flow are information. The stage for design reviews — a frame must never run off the bottom of the screen.
  - **The reviewer's place is never lost.** Clicking a frame's plate in grid opens *that* frame in slides; leaving slides restores the grid scroll position; the current view + frame mirror into `location.hash` (`#slides-2`, `#proto-1`) so any review state is linkable — "look at slide 2" is a URL, not directions.
  - **Theme** — a light ⇄ dark toggle. Precedence: the reviewer's own last choice (localStorage) wins, then an authored `data-theme` on `<body>` (a presenter's choice survives the room's OS), then the OS preference. The half-tone swatch leads with the current mode — it reads as state. Both ramps ship in every HTML artifact. Visually distinct from the view tabs — it's a mode switch on the stage, not a way of looking at the frames: a borderless control, separated from the view group. Figma and pencil artifacts are single-theme — the ask-first step records which.
  - **Prototype** (only when requested) — one screen at a time on the same fitted stage, annotations hidden, and the wireframes themselves interactive: activating a trigger element (the real button, the real row — click, or Tab + Enter/Space) navigates to the screen it leads to, following the flow logic. **Navigation is flow-shaped, not document-shaped:** ←/prev steps back through *visited* screens, Restart returns to the flow's entry, and sequential paging (next, the linear position) hides — arrows that walk document order would let a reviewer traverse paths the flow never connects. Only the wired triggers are tabbable; the mock's unwired controls leave the tab order, and a dead tap flashes a hairline "nothing here" acknowledgment. Hovered triggers show the same hairline ring — wired controls distinguish themselves from decoration. The view instructs itself: the navigator row carries a one-line sentence-case hint — the demo moment must never be an unlabeled room.
- **Wireflow arrows** connecting screens render on the backdrop, between frames — flow logic lives in the container layer, never inside a screen.
- In Figma, the container maps to sections and frame layout on canvas; in pencil, to grouped frames. Slideshow falls to those tools' native presentation modes.

**Slideshow is not prototype.** Slideshow pages through frames in section order — a presentation. Prototype view makes the wireframes themselves the simulation — the actual trigger elements are clickable and navigate the flow. Slideshow is always available; prototype view exists only when the user asked for a prototype. Both ride the same single HTML artifact.

### Layer 2 — Wireframe content (the kit)

Source of truth: `references/design-system.css`. Wireframe content uses its variables and classes, and nothing else.

**The palette** — a five-role grayscale ramp, one working accent, one semantic exception:

| Variable | Light | Dark | Used for |
|---|---|---|---|
| `--w-canvas` | `#ffffff` | `#1a1a20` | the screen's own background |
| `--w-surface` | `#f4f4f6` | `#232329` | cards, panels, filled regions |
| `--w-border` | `#d6d6dd` | `#3a3a44` | outlines, dividers, input boxes |
| `--w-ink2` | `#62626b` | `#9a9aa6` | supporting text (guardrail: ≥4.7:1 on surface) |
| `--w-ink1` | `#26262e` | `#e8e8ee` | headings, labels, body text |
| `--w-accent` | `#4338ca` | `#7c6ff0` | primary actions + selection states, nothing else |
| `--w-accent-soft` | `#edebfc` | `#2d2a4e` | tinted surfaces paired with accent/ink text |
| `--w-error` | `#b42318` | `#f97066` | invalid states ONLY — never decorative, never emphasis |

The Intent indigo accent marks **what is primary and what is selected** — filled primary buttons, active chips, checked checkboxes and radios, switched-on switches, focus rings, the active tab underline. It expresses interaction state, not visual design: it is the system's fixed accent, not a color choice on offer. Everything else stays in the ramp — if a tone isn't telling the user "this is the primary action", "this is selected", or "this is invalid", it stays gray. The annotation layer shares the same indigo but speaks in its own shapes (numbered markers, the notes rail), never in controls.

**The token law.** Every size, margin, gap, padding, radius, control height, icon size, type size, and line-height comes from the kit's tokens — spacing `--sp-N` = N×4px (up to 92), control heights 32/40/48, icons 16/20/24/32, radii 2/4/8/full. **Raw pixel values in artifact markup are a violation.** The 4px grid is absolute.

**The type scale** — grid-locked size/line-height pairs with legible floors (nothing under 11px): `t-caption` 11/16 · `t-small` 13/20 · `t-body` and `t-body-strong` 14/20 · `t-heading` 16/20 · `t-title` 18/24 · `t-display` 22/28. One neutral system font (`--wf-font: system-ui` — never the brand fonts, which belong to the chrome); size and weight express hierarchy, never typeface.

**Glyphs — two roles, one rule.** Functional icons (chevron, search, check, ×, plus, bell, camera, alert, back-arrow, info) are drawn SVG, alpha-masked so they render in currentColor: `.glyph .gl-search` etc. **Never use text characters (▾, ×, ⚙) as control glyphs.** The featureless `.icon` circle is the placeholder for app-specific icons that aren't decided yet. An icon-only button (`.btn-icon`) always carries an `aria-label`.

**The component baseline** — the kit covers the real anatomy of screens, all with working states:

| Element | Kit vocabulary |
|---|---|
| Buttons | `.btn` + `.btn-primary` (accent-filled) / `.btn-secondary` (bordered) / `.btn-ghost`, sizes `.btn-sm`/`.btn-lg`, `.btn-block`, `.btn-icon` + aria-label |
| Form fields | `.field` > `.field-label` + `.input`/`.textarea`/`.select` + `.field-hint`; `.search` (input + leading glyph); invalid = `.error` class + `.field-error` line with `gl-alert` |
| Choices | `.choice` rows: native checkbox / radio (accent when checked); switch = **`button.switch[role=switch]`**, never a styled checkbox |
| Chips / tabs | `.chip` (accent-filled when active), `.tabs` > `.tab-item` (accent underline), `.tabbar` > `.tab` (mobile bottom bar) |
| Bars | `.appbar` — back glyph, title, contextual actions |
| Objects | `.avatar` (sm/md/lg), `.media` (light gray block — surface fill, hairline border, no crossed lines), `.badge` (+ `-muted`/`-accent`), `.link`, `.divider` |
| Collections | `.card` (+ `.interactive`) > `.media` + `.card-body`; `.list` > `.list-row`; native `<table>` with real headers and real rows |
| Overlays | `.scrim` + `.modal` (+ `.modal-actions`), `.sheet` + `.sheet-handle`, `.toast` — elevation is **a scrim plus a hairline border, no glow shadows** |
| Alerts | `.callout` > `.glyph` + `.callout-body` (`.callout-title` + `.callout-text`) — persistent in-page note, the toast's standing counterpart. Neutral default, `.accent` for emphasis, `.error` for the ramp's one semantic exception. **Severity reads from glyph + copy, never hue** (the ramp has no success/warning color); never a left accent stripe |
| Loading | `.skeleton` for content; `.spinner` only inside controls, always with an honest label ("Posting…") — the label carries the state, motion just reinforces it, and reduced-motion users get a static treatment |
| Layout | `.row`, `.stack`, `.text-stack` (a name/title over a sub-line as one identity unit — collapses leading to a single grid step), `.grow`, `.grid-2`, `.grid-3`, `.screen-body` |
| Vignettes | `.vignette` (+ `.dots` — a **board-level** grid option, all vignettes or none, only when the dots mean something) > `.float`; `.idea-caption` > `.idea-num` + `.idea-title` + `.idea-desc` |

**The completeness test.** A mid-fi wireframe is a grayscale version of the full product screen — not an enlarged fragment. If the real screen would have it, the wireframe has it: status and navigation bars, tab bars, search fields, filter chips, icons (placeholders where undecided), avatars, timestamps, counts, secondary actions, footers. Density matches reality — a marketplace grid shows six listings with sellers and distances, not two bare cards; a feed shows the fold and what's below it. The test: screenshot the real product, desaturate it, strip the brand typography — your wireframe should have the same amount of stuff in the same places.

**Real controls.** Wireframes are built from native interactive elements — `<button>`, `<input>`, `<textarea>` — never divs painted to look like controls. Text inputs focus and accept typing, buttons respond to hover and press, chips and switches toggle, tabs react. Interaction states are mandatory and live in the kit: hover, focus (2px accent ring), press, disabled, invalid, loading. Interactivity is not polish — it's structural truth about what the screen *does* — so it belongs at this rung; only visual styling is withheld.

### Layer 3 — Annotation (accent meta-layer)

Notes about the design, never part of it:

- **Numbered markers** — small accent-colored circles with white numerals, placed on the wireframe; each pairs with a note in a rail in the container margin. **Notes are per wireframe, never one consolidated list:** markers number per frame (each wireframe restarts at 1), and each frame's notes live in a `.note-group` carrying `data-for="<frame-id>"`, headed by a `.note-frame` line naming the frame. Grid view shows every group as the section's record, in a right sidebar beside the frames; slides view shows only the active frame's group. Section-level notes sit outside any group and always show. **The notes rail is a mid-fi feature** — idea boards carry no rail; their captions are the annotation. Anchor markers to the element they annotate (a `position: relative` container, token offsets) — never frame-level percentage positions that drift over the content.
- **Idea captions** — on lo-fi vignettes, the caption's index number carries the annotation accent: the number narrates the board, it isn't UI.
- **Flow indicators** — "links to →" labels on wireflow arrows.

(Prototype interactivity is not an annotation overlay — it lives on the wireframe's own trigger elements and is invisible by design; see the Prototype view.)

Annotation uses **one accent: Intent indigo by default (`--note`), overridable by the user at generation time** ("use green for annotations"). The override swaps `--note` only — the kit's content accent (`--w-accent`) is fixed. Annotation shapes are how the layer stays distinct from content even though they share the default indigo: markers and rail text, never buttons, never fills. If the user's requested accent collides with grayscale legibility, say so and suggest an alternative.

## Visualization & output

For this skill the artifact is the deliverable. After the structural thinking is done — never before — produce wireframes in the format the user chooses.

### Ask first

Open with this question, with HTML as the default:

> Where should these wireframes live?
>
> - **HTML** (default) — self-contained file per fidelity stage: grid/slideshow viewer, optional click-through prototype
> - **Figma** — frames and sections in your Figma file via MCP
> - **pencil** — frames in pencil.dev via MCP
> - **No** — markdown structure spec only

Skip the question if the request already states a preference — "in figma", "in pencil", "html", "just describe it", "no wireframes" preempt the prompt. If the user says yes without naming a format, default to HTML. Ask for section names if sets aren't already implied by the flow ("Should I group these as Onboarding / Checkout, or differently?").

If the user picks **Figma or pencil**, also ask: **light or dark wireframes?** Those canvases are single-theme — use the chosen column of the palette throughout. HTML needs no theme question; it ships both ramps with an in-page toggle.

### HTML output

Write **one self-contained file per rung** — `wireframes-<topic>-thumbnails.html` for the lo-fi idea board, `wireframes-<topic>.html` for full-page wireframes and prototypes — to the working directory and open it. Never mix rungs in one file: they serve different project stages. No external `<link>`, `<script src>`, fonts, or images — inline `<style>` and inline `<script>` only.

**Embed the system verbatim.** Read these three files from this skill's `references/` directory and paste their full contents into the artifact — never retype them, never improvise replacements, never trim "unused" parts (the next iteration uses them):

1. `references/design-system.css` → into `<style>`, first
2. `references/viewer.css` → into the same `<style>`, after it
3. `references/viewer.js` → into `<script>` before `</body>`

(If your platform has inlined these reference files below this document, embed that copy.) After the two stylesheets, add per-artifact layout CSS — screen-specific grids, zone sizing, marker positions — using kit tokens for every value. Raw pixels are a violation; so is restyling a kit class.

**Structure template** — fill with real screens:

```html
<!-- in <head>: a data-URI favicon (no 404 noise in the console) —
     the annotation marker is the mark:
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Ccircle cx='8' cy='8' r='6' fill='%234338ca'/%3E%3C/svg%3E">
-->
<!-- data-theme pins the authored theme; OMIT it to follow the viewer's
     OS preference. A pinned theme survives the presentation room. -->
<body data-view="grid" data-theme="light">
  <header class="board-header">
    <div class="board-id">
      <h1 class="board-title">[PROJECT] — wireframes</h1>
      <p class="board-meta">Intent /wireframe · [MONTH YYYY] · [RUNG]</p>
    </div>
    <div class="board-controls">
      <nav class="view-toggle" aria-label="View">
        <button data-setview="grid" aria-pressed="true">Grid</button>
        <button data-setview="slides" aria-pressed="false">Slides</button>
        <!-- Include ONLY when a prototype was requested: -->
        <button data-setview="proto" aria-pressed="false">Prototype</button>
      </nav>
      <button class="theme-toggle" data-toggle-theme>
        <span class="swatch" aria-hidden="true"></span><span class="theme-label">Dark</span>
      </button>
    </div>
  </header>

  <!-- in the stage views this row replaces the section label:
       name · position grouped left, controls right. Each view carries
       its own quiet hint; proto swaps sequential next for Restart -->
  <nav class="slide-nav">
    <span class="slide-section">[SECTION NAME]</span>
    <span class="slide-pos">1/1</span>
    <span class="nav-hint slides-hint">← → to page · Esc returns to grid</span>
    <span class="nav-hint proto-hint">Tap live controls to navigate · ← steps back · Esc returns to grid</span>
    <button data-prev aria-label="Previous"></button>
    <button data-next aria-label="Next"></button>
    <button data-restart>Restart</button>
  </nav>

  <section class="board-section" data-section="[SECTION NAME]">
    <h2 class="section-label">[SECTION NAME]</h2>
    <div class="frame-grid">

      <!-- mid-fi frame: plate above (an h3 — screen readers jump frame
           to frame by heading; viewer.js makes it the click-to-open-in-
           slides handle), complete interactive screen inside -->
      <article class="frame" id="scr-[slug]" style="width: [VIEWPORT]px">
        <h3 class="frame-plate">
          <span>[SCREEN NAME]</span>
          <span class="frame-pos">[N/TOTAL]</span>
        </h3>
        <div class="wf" style="position: relative;">
          <!-- the full screen, kit vocabulary only. Controls are NATIVE
               elements — <button class="btn btn-primary">, <input
               class="input">, <button class="chip"> — never painted divs.
               When a prototype was requested, put data-go="scr-[target-slug]"
               directly on the real trigger elements. -->
          <!-- annotation markers (absolute-positioned, token offsets): -->
          <div class="note-marker" style="top: …; left: …;">1</div>
        </div>
      </article>

      <!-- lo-fi frame: no plate — the idea caption is the label -->
      <article class="frame" style="width: 360px">
        <div class="wf">
          <div class="vignette"><!-- or class="vignette dots" -->
            <div class="float" style="max-width: 280px">
              <!-- the focused real-UI fragment where the idea lives -->
            </div>
          </div>
          <div class="idea-caption">
            <span class="idea-num">#[N]</span>
            <p class="idea-title">[MECHANISM NAME]</p>
            <p class="idea-desc">[One breath: what the idea is and why it might win.]</p>
          </div>
        </div>
      </article>

    </div>
    <!-- MID-FI ONLY — idea boards carry no rail; the board stays a clean grid -->
    <aside class="note-rail">
      <!-- one group per frame; markers restart at 1 inside each frame -->
      <div class="note-group" data-for="scr-[slug]">
        <p class="note-frame">[SCREEN NAME]</p>
        <p><span class="note-num">1</span> [WHY this element is here / open question]</p>
      </div>
      <!-- section-level notes sit outside any group and always show -->
    </aside>
  </section>
</body>
```

**Rules:**

- Wireframe content uses kit variables and classes (`--w-*`, `.wf` vocabulary) only. Chrome uses `--stage`/`--chrome-*` only. Annotation uses `--note` only. The layers never share a variable.
- Don't invent class names — the kit's vocabulary is the language, and the reference CSS is its law. If a screen needs something the kit lacks, compose it from kit primitives and tokens; if it's genuinely new, that's a design-system change, not an artifact improvisation.
- Every dimension in per-artifact CSS and inline styles comes from tokens (`--sp-*`, `--h-*`, `--ic-*`, `--r-*`, `--t-*`). Viewport widths are the exception: frames render at real device widths — 1440 (desktop), 768 (tablet), 390 (mobile); vignette frames at ~360px.
- Light + dark ship together; the chrome's Theme toggle flips both. Initial theme: the reviewer's saved choice, then an authored `data-theme` on `<body>`, then the OS. Don't strip either ramp.
- Include the Prototype view button and `data-go` attributes ONLY when the user asked for a prototype. `data-go` goes on the actual trigger element — the prototype IS the wireframe, not an overlay on it.
- Real labels, real content. No lorem ipsum, anywhere, ever.
- Controls are native elements with working interaction states — inputs type, buttons hover and press, chips and switches toggle. A div painted as a button is a vocabulary violation. The accent appears only where the kit puts it: primary actions, selection states, focus. `--w-error` appears only on invalid states.

### Figma output

When the user picks Figma, confirm light or dark (per Ask first), load the `/figma-use` skill first (mandatory), then call `mcp__claude_ai_Figma__use_figma`. Translate the language using the chosen theme's column of the palette throughout:

- Container sections → Figma sections named per user-defined groups; title plates → small mono text labels above each mid-fi frame (uppercase, chrome ink `#65657a` light / `#8888a8` dark).
- Each screen → a frame at real viewport width, fill = the chosen theme's canvas, 1px stroke = the chrome border (`#d8d8e4` light / `#2a2a44` dark). Lo-fi vignettes → a surface-filled panel with the fragment centered and the idea caption below.
- Wireframe content → the palette values as fills/strokes exactly as in the table above, on the 4px grid with the kit's control heights and type scale; one neutral font (Inter or SF); the accent on primary actions and selection states only; media blocks are surface-filled rectangles with a hairline border — no crossed lines; functional glyphs as simple drawn vectors, undecided icons as featureless circles.
- Annotation → a locked overlay group per frame: accent circles with white numbers (`#4338ca` light / `#7c6ff0` dark, or the user's override), plus a notes text block beside the frame.
- Wireflow arrows → connectors between frames on the canvas, never inside frames.

### pencil output

When the user picks pencil, confirm light or dark (per Ask first), call `mcp__pencil__get_editor_state` then create a new document, set the chosen theme's palette + annotation accent as variables via `mcp__pencil__set_variables`, then `mcp__pencil__batch_design`: one frame per screen at real viewport width (vignette panels for lo-fi), grouped per section, components per the kit's conventions (4px grid, control heights, accent on primary/selection only, media blocks surface-filled with no crossed lines), annotation markers in the accent, connectors between frames for wireflows.

### Fidelity enforcement

The output stage enforces the doctrine:

- A vignette sprawling into a whole screen (nav bars, multiple zones, content beyond its one idea) is a rung violation — say so and offer to step up: *"This idea wants a full screen — should I promote it to the wireframe artifact?"* The inverse is also a violation: a vignette going abstract (gray boxes standing in for the idea itself) gets redrawn from the kit — nothing is ever drawn vaguer to look "early".
- A request for color palettes, typefaces, or styling inside wireframe content is a hard-stop violation — refuse and route: *"That's visual design — the wireframe stays in the locked grayscale system so the critique stays structural. Take the styled pass to your visual design tools once the structure is agreed."* The single exception is the user-configured annotation accent, which never touches content.

## Core capabilities

### 1. Screen anatomy & zoning

Decompose any screen into named zones with one job each: where global navigation lives, where local context lives, where the primary content sits, where actions cluster, where system status appears. A zone with two jobs is two zones drawn as one — split it. A zone you can't name by its job ("misc", "other stuff") doesn't have a reason to exist yet.

Work top-down: name the zones and their jobs before drawing elements within them. Never let element-level decisions leak into zone-level conversations.

### 2. Hierarchy without styling

Express importance using only structure: size, weight, position, and grouping. The most important thing on the screen should be findable in a five-second squint test of the wireframe. If hierarchy needs color to work, the hierarchy doesn't work — the kit's accent marks the primary action and what's selected, but it cannot rescue a structure where everything competes; brand color can reinforce structural hierarchy later, it cannot create it.

Position carries meaning: top-left (in LTR locales) is read first; above the fold is a real boundary at real viewport heights; proximity implies relationship. Flag every position decision that assumes a locale for `/localize`.

### 3. Layout patterns

Carry the standard structural patterns and when each fits:

- **Single column** — focused linear tasks (forms, articles, mobile-anything). Fails when users need to compare.
- **Sidebar + content** — persistent navigation or filters beside a working area. Fails below tablet width; plan the collapse.
- **Master-detail** — list beside selected item. Fails when the detail needs full attention or the list is the task.
- **Card grid** — browsing peers of equal weight. Fails when items need comparison on specific attributes (that wants a table).
- **Dashboard zones** — status-first scanning, most-important top-left. Fails when everything is "important" — a dashboard with twelve equal widgets has no hierarchy at all.
- **Wizard** — one decision per screen. Fails when users need to see the whole; pair with a progress structure.

Recommend by the user's task, not by what's common. The pattern is a starting structure, not an answer.

### 4. Content-first wireframing

Real content is a structural material, not a finishing touch — at every rung, vignettes included. Wireframe with the real label ("Storage used — 14.2 GB of 15 GB"), the real edge case (the German compound word, the 47-item list, the zero-state), the real data shape. Lorem ipsum hides exactly the problems wireframes exist to find: labels that don't fit, tables that overflow, hierarchies that collapse when the real numbers arrive. When real content isn't known yet, write honest plausible content and flag it for `/articulate`.

### 5. Annotation discipline

A wireframe shows what; annotations carry why. Annotate decisions, not inventory: "search is in the header because support data shows nav-first users fail 40% of the time" earns a marker — "this is the search box" does not. Number markers, keep notes in the rail, and mark open questions as questions ("does legal require the disclaimer above the fold?"). Un-annotated wireframes invite the real-estate-tour reading; over-annotated ones bury the three decisions that matter under twenty that don't.

### 6. Wireflow & prototype assembly

Materialize flow logic from `/journey` as connected screens. Lay frames in flow order, draw connections in the container layer, and label what triggers each transition. When the user wants a prototype, make the actual trigger elements navigate — the real button, the real list row — not whole-screen jumps, so walking the prototype rehearses the real interaction. Prototypes are click-through only: no conditional logic, no state simulation. When a flow needs state to be testable, that's a finding to hand back to `/journey`, not a feature to fake.

### 7. Divergence practice

For any new problem, ideas come first and come plural. Draw mechanically different vignettes — different answers to "what mechanism solves this?", not the same mechanism with the button moved. If all your ideas look alike, you've decided the answer without noticing. Present alternatives with the trade-off named in each caption, converge deliberately with the user, then promote the chosen mechanism up a rung — into the screens of its own wireframe artifact. The idea board stays behind as the decision record, rejected vignettes and all — what was chosen against is part of the design.

## Output format

Structure the deliverable as the work requires. The full toolkit:

1. **Screen inventory** — What screens or ideas are in play, at what rung, grouped into which sections. The shared map of the artifact.
2. **Structural rationale** — Per screen: what its primary job is, what zones exist and why, what hierarchy was chosen and why. Per vignette: what mechanism it proposes and what trade it makes. The reasoning the wireframe renders.
3. **The artifact** — HTML (default), Figma, or pencil, per the ask-first protocol. The wireframes themselves, in the three-layer language.
4. **Annotations** — Numbered decisions and open questions, in the annotation layer and recapped in text.
5. **Considered & rejected** — Vignettes that lost, with one line each on why. Lives in the idea-board artifact.
6. **Handoffs** — What goes to `/articulate` (flagged placeholder copy), `/fortify` (states not yet wireframed), `/journey` (flow findings), `/specify` (when structure freezes).
7. **Pending questions** — What needs `/organize`, `/investigate`, or stakeholder input before structure can freeze.

## Voice & approach

- **Structure before surface, always.** Refuse to debate aesthetics at the wireframe rung — park those notes for visual design and keep the critique structural.
- **Divergent first, convergent deliberately.** Offer alternatives before recommending. The first mechanism that comes to mind is the most familiar, not the best.
- **Name the rung.** Every artifact states what fidelity it is and what feedback it wants. Mismatched feedback is the presenter's fault, not the audience's.
- **Real content is non-negotiable.** Push back when asked to "just put placeholder text in" — explain what lorem ipsum hides, then write honest content.
- **Decisions over inventory.** Every annotation explains a why. If a wireframe walkthrough sounds like a real estate tour, the rationale is missing.

## Scope boundaries

**You own:**
- Structural layout of individual screens at lo-fi and mid-fi
- The fidelity ladder and choosing the right rung for the decision at hand
- The wireframe language: container chrome, content kit, annotation layer — and its reference files
- Wireflows and click-through prototypes assembled from defined flow logic
- Structural hierarchy, zoning, density, and layout pattern selection
- Annotation of structural decisions and open questions

**You don't own:**
- Flow logic across screens — what screens exist, in what order, with what branches (`/journey` defines it; you materialize it)
- Information architecture, taxonomy, and navigation models (`/organize` structures it; you place it)
- Final copy, voice, and tone (`/articulate` — your real-content placeholders are flagged for their pass)
- Visual design: color palettes, typography, styling, brand (outside the Intent system entirely — you stop where it starts)
- Edge-case and state hardening (`/fortify` — invite them before structure freezes; the kit's error, loading, and skeleton vocabulary renders what they specify)
- Engineering specs (`/specify` — your annotated wireframes are their input)
- Accessibility auditing (`/include` — but reading order, target placement, and the kit's baked-in floors: legible type, focus rings, aria-labeled icon buttons, real roles — are your structural responsibility)

**Always ask:**
- What is this screen's primary job — and does the structure make that job obvious?
- What decision is the team trying to make, and what's the lowest rung that supports it?
- What's the real content — labels, data shapes, worst-case lengths?
- What precedes and follows this screen in the flow?
- What would a five-second squint test say is most important here?
- Which structural decisions are assumptions that `/investigate` or stakeholders need to confirm?

## Working with this skill

Bring the flow definition (from `/journey` or your own notes), the information being presented, any real content you have, and the device targets. Name the decision you're trying to make — "which mechanism?", "is everything here?", "does the sequence work?" — and the skill will pick the rung to match. Expect alternatives before recommendations, the locked grayscale system until structure is agreed, and pushback if the conversation drifts to fonts before the layout has earned them.