Skip to main content
skill CX Codex

interaction-design-board — Claude Code skill: what it does

The interaction-design-board skill builds several clickable HTML prototypes of one interface into a Design Board where you pick a variant or request a remix before the agent touches production code.

MIT 213 installs ★ 1,540 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daymade/claude-code-skills --skill interaction-design-board -a claude-code
Open on GitHub

What interaction-design-board does

The skill locks product facts (data, actions, design tokens) and generates three or more self-contained HTML files with different interaction architectures: what appears first, what stays hidden, how the user moves between states. Every prototype runs in the browser, and all of them embed into the Design Board — a page where you switch between variants, leave feedback, and choose the final solution. The skill runs build_board.py, which rejects identical candidates and external dependencies, then opens the Board via gstack design serve or directly in the browser.

Use it for navigation choices, detail disclosure, action sequencing, or information hierarchy. For static style calibration there is design-style-picker. Without Python 3 and the build_board.py script the Board will not build.

What it helps with

  • build several clickable interface variants with different action hierarchies
  • choose an interaction structure before changing production code
  • compare progressive disclosure and navigation models in one place
  • lock business facts and design tokens while varying behavior only
  • get feedback on working prototypes rather than screenshots

Example prompts for the agent

  • Build a Design Board for the checkout page: one variant with the form at the top, another with the cart on the left, a third one step-by-step
  • Generate three dashboard prototypes with different navigation and open the Board
  • Build a Board for the product card: tabbed variant, accordion variant, single-column variant

How to install interaction-design-board

1Skills CLI (Vercel)

npx skills add daymade/claude-code-skills --skill interaction-design-board -a claude-code

2Manually: put the files in place

~/.claude/skills/interaction-design-board/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/interaction-design-board/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about interaction-design-board

How to install interaction-design-board in Claude Code?

Run npx skills add daymade/claude-code-skills --skill interaction-design-board -a claude-code, then the agent will load ~/.claude/skills/interaction-design-board/SKILL.md.

What does interaction-design-board do?

The skill generates several self-contained HTML prototypes of one interface with different interaction architectures, assembles them into a Design Board, and waits for selection or a remix request before editing production code.

What does interaction-design-board require to work?

Python 3 and the build_board.py script from the skill repository. Without them the Board will not build. Running the server needs gstack design, but the Board also works when the HTML file is opened directly.

Source text

SKILL.md · MIT
---
name: interaction-design-board
description: >-
  Generates several distinct, clickable HTML interaction prototypes for one product surface into a
  Design Board and collects selection/remix feedback before implementation. Use for multiple UI
  versions, interaction alternatives, progressive-disclosure options, or when styling is fine but
  hierarchy/workflow/interaction feels off. Not for static visual-style calibration (use
  design-style-picker) or a settled CSS tweak.
---

# Interaction Design Board

Turn interaction uncertainty into inspectable evidence. Keep the product's real
facts and design language fixed; vary the interaction architecture enough that the
user can experience the trade-offs before production code changes.

## Route The Request

- Use this skill when the choice depends on behavior, state, workflow, hierarchy,
  or progressive disclosure.
- Use `design-style-picker` for static visual-style calibration and image matrices.
- Use gstack's `design-consultation` for a new product-wide design system and
  gstack's `design-shotgun` for static generated mockups.
- Return to this skill after a visual direction is chosen if the user still needs
  to compare clickable interaction structures.
- Do not use it for a settled one-line CSS adjustment or when the user already
  supplied an approved interaction specification and asked only for implementation.

## Non-Negotiable Outcome

Produce a decision, not a gallery:

1. Several runnable HTML candidates keep the same business facts, product scope,
   design tokens, and available actions.
2. Each candidate embodies a distinct interaction hypothesis rather than a skin.
3. The Design Board lets the user operate every candidate, record concrete
   feedback, select one, or request a named remix.
4. Production implementation does not start until the user approves the behavior.

Static screenshots are supporting evidence only. A screenshot cannot prove a
collapse state, keyboard path, selection model, or task handoff.

## Workflow

### 1. Freeze The Decision Contract

Before generating variants, write a compact contract in the session workspace:

- **User job:** the real task the operator is trying to complete.
- **Decision scope:** the one page, component, or bounded journey being compared.
- **Immutable facts:** real objects, labels, statuses, permissions, actions, and
  data semantics that every variant must preserve.
- **Existing language:** current tokens, components, navigation, density, and
  brand assets that must remain recognizable.
- **First-view invariant:** what must stay visible before any disclosure.
- **Interaction states:** the meaningful states the user must be able to exercise.
- **Stop condition:** approved variant or explicit remix brief; no product edit yet.

For an existing product, inspect its rendered page and implementation before
writing the contract. Do not replace unknown facts with plausible sample data. Mark
unknowns as unknown or omit them if they are not needed for the interaction choice.

When the decision replaces a screen that already ships, enumerate its current
user-visible behaviors as a numbered inventory during that inspection: every action,
state, deep link, keyboard path, empty state, and copy affordance. Candidates are free
to defer or drop any of them — the inventory exists so that a dropped behavior is a
stated trade-off rather than an unnoticed regression.

Read `references/interaction-design-method.md` before proposing the candidate
architectures. It contains the hierarchy, progressive-disclosure, comparison, and
accessibility rules that decide whether a direction is legitimate.

### 2. Propose Different Interaction Architectures

Propose three candidates by default. Add candidates only when another independent
interaction hypothesis exists; do not inflate the board with minor variants.

For each candidate state:

- the hypothesis about how it helps the user's job;
- what it makes primary;
- what it defers or hides;
- the likely trade-off;
- the states and actions that must work in the prototype.

Hold the decision contract constant. Change navigation/selection/disclosure/action
ownership or information order—not colors, copy, and data all at once. Useful
families include command-first, queue-detail, object-led, comparison-led, and
ledger-first, but derive candidates from the current task rather than filling a
pattern quota.

### 3. Generate Isolated Runnable Candidates

Create one self-contained HTML file per candidate in a session workspace outside
the product source tree. Keep CSS and JavaScript inline; avoid runtime network
dependencies so every prototype survives inside the Board.

When independent worker contexts are available, assign one candidate to each
worker with the same frozen decision contract and only that candidate's hypothesis.
Do not let workers see one another's output. This isolation is the test-time-scaling
mechanism: it preserves distinct hypotheses instead of converging into siblings.
If workers are unavailable, generate serially but re-read the frozen contract—not
the previous candidate—before starting the next one.

Each candidate must implement the declared states. Decorative buttons that do
nothing are not interaction prototypes. Use honest local state; do not simulate a
backend response the product does not have.

### 4. Build And Open The Design Board

Create `board.json` using `references/board-contract.md`, then run:

```bash
SKILL_ROOT="<absolute directory containing this loaded SKILL.md>"
python3 "$SKILL_ROOT/scripts/build_board.py" \
  --manifest <session-dir>/board.json \
  --output <session-dir>/design-board.html
```

Expected output:

```text
BOARD_BUILT variants=<derived count> output=<absolute path>
```

The builder rejects byte-identical candidates, path traversal, missing declared
states, and static external styles, scripts, or media. The Board also injects a
network-denying Content Security Policy into every sandboxed candidate so dynamic
JavaScript cannot create an undeclared runtime dependency. Fix the candidate; do
not weaken either boundary to make the Board green.

If gstack's design executable is already installed, resolve its absolute path from
the active gstack Skill installation; do not assume `$D` exists in a new shell. Then
capture the exact Board URL printed by the server:

```bash
GSTACK_DESIGN="<resolved gstack design executable>"
SERVER_OUTPUT="$("$GSTACK_DESIGN" serve \
  --html <session-dir>/design-board.html --timeout 1800 2>&1)"
printf '%s\n' "$SERVER_OUTPUT"
BOARD_URL="$(printf '%s\n' "$SERVER_OUTPUT" | sed -n 's/^BOARD_URL: //p' | tail -1)"
test -n "$BOARD_URL"
```

If the executable cannot be resolved or the command prints no `BOARD_URL`, open
`design-board.html` directly with the host's browser-opening tool. Direct-file mode
remains functional: Submit and Remix download `feedback.json` or
`feedback-pending.json` for the agent to read. The Board itself is the chooser;
chat is only the fallback channel.

### 5. Observe Tasks, Not Vibes

Ask the user to operate the same representative task in every candidate. Record:

- what they noticed first;
- where they knew or did not know what to do next;
- which disclosure helped or hid necessary evidence;
- which state transition felt natural or surprising;
- which elements to preserve, reject, or remix.

Do not replace these observations with a numeric score or a claim that the most
polished candidate is best. The user may choose one candidate or combine named
parts of several.

When `feedback-pending.json` appears, preserve the accepted parts, alter the named
failure axis, regenerate only the affected candidates, and build a versioned Board
file in the same session directory. If a gstack Board is already serving, reload
that exact Board instead of calling `serve` again on the old source path:

```bash
curl -sS -X POST "${BOARD_URL%/}/api/reload" \
  -H 'Content-Type: application/json' \
  -d '{"html":"<absolute-versioned-board-path>"}'
```

Expected response: `{"reloaded":true}`. Repeated `serve` calls may reuse a Board
instance without reading changed bytes, so they are not a reload mechanism. Ask the
user to retry the task in the same Board URL. Stop adding rounds when feedback no
longer changes the decision.

### 6. Freeze Approval Before Production

After the user confirms your feedback summary, write `approved.json` beside the
Board using the schema in `references/board-contract.md`. Capture:

- selected or remixed candidate;
- approved interaction rules and first-view invariant;
- rejected trade-offs;
- states the user actually exercised;
- remaining unknowns;
- exact prototype file identities.

Then—and only then—implement in the product. Preserve the current design system and
real data contracts. Use the project's frontend implementation and visual-QA skills,
then verify the same representative task in the real browser. Pixel resemblance is
insufficient; the approved state transitions and information order must survive.

If you built a behavior inventory in step 1, the implementation is not delivered until
every line of it carries a disposition: kept, changed to what, or dropped and why. Put
that table where reviewers of the change will read it, not only in the session
workspace. The removals are the load-bearing rows — a behavior nobody can account for
is a regression that was never filed, and the author is the last person able to notice
it. Expect the count of intentional removals to be wrong on the first pass; recheck it
against the inventory before calling the change complete.

If the project has a design SSOT, write the approved interaction decision there as
part of implementation. Keep session feedback and prototype files as evidence; do
not copy their changing values into general project instructions.

## Failure Boundaries

- Do not turn every candidate into a different product or data model.
- Do not let static image generation stand in for runnable interaction.
- Do not hide identity, current status, primary evidence, or the next action behind
  progressive disclosure when they are necessary to decide.
- Do not implement the apparent winner before the user has operated it.
- Do not write prototypes into production component directories.
- Do not claim usability validation from the author's own click-through. Agent QA
  catches broken states; the user's task observation decides the interaction.

## Delivery

Return the Board path or URL, candidate hypotheses, feedback/approval artifact
paths, browser verification performed, and the explicit next step: iterate the
Board, implement the approved candidate, or stop.

© daymade · MIT · daymade/claude-code-skills

Similar skills

All skills for Design →

From the same set102

The whole set →
read-claude-code-history read-claude-code-history is a Claude Code skill for searching and exporting local conversation history. It finds original user messages, session context, and evidence of commands or tool calls. CX Codex +1 223installs read-codex-history read-codex-history — a skill for Codex, Claude Code, Cursor, GitHub Copilot and Gemini CLI that reads, searches and exports local OpenAI Codex session history without resuming any prior task. CX Codex +1 221installs prior-work-retrieval prior-work-retrieval is a Claude Code skill that surfaces and inspects past project deliverables before creating new components. Activates on explicit reuse requests. CX Codex +1 218installs continue-claude-code-work continue-claude-code-work restores interrupted Claude Code work from session history, identifies unfinished requests, and selects the next verified action. CX Codex +1 216installs codex-1m-context-window-setup codex-1m-context-window-setup inspects Codex context settings, adjusts auto-compaction, and applies a model-aware expansion toward 500K or 1M when supported. CX Codex +1 211installs lark-cli-router lark-cli-router routes Feishu, Lark, and Doubao tasks to version-matched guides in lark-cli. Helps agents manage docs, calendar entries, and chat tasks safely. CX Codex +1 210installs excalidraw-use excalidraw-use lays existing images out on an Excalidraw scene in a grid, shoots Vite/React slides to separate images, and reads a .excalidraw file for broken pictures. CX Codex +1 187installs meme-creator The meme-creator skill tracks moving objects in a clip and places logos, avatars, or stickers over them, then exports MP4 and GIF files. Use it to make a reaction meme from footage. CX Codex +1 174installs

Project sponsors

Companies that keep this analytics open