build-prototype
/build-prototype
Use when the user wants a prototype, mockup, clickable demo, design options or "something to show" for an item with approved behaviour trees. Step 4 of the pipeline - builds one self-contained clickable HTML file with two or three hypothesis-led design variants, where every tree branch can be demonstrated in every variant, and proves that coverage with the checker.
- Author
- Mosin112 ↗
- Repository
- pm-harness ↗
- Licence
- MIT
- Last repository change
- 12.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when the user wants a prototype, mockup, clickable demo, design options or "something to show" for an item with approved behaviour trees. Step 4 of the pipeline - builds one self-contained clickable HTML file with two or three hypothesis-led design variants, where every tree branch can be demonstrated in every variant, and proves that coverage with the checker.
Triggers from the description
Original author description
Use when the user wants a prototype, mockup, clickable demo, design options or "something to show" for an item with approved behaviour trees. Step 4 of the pipeline - builds one self-contained clickable HTML file with two or three hypothesis-led design variants, where every tree branch can be demonstrated in every variant, and proves that coverage with the checker.
How it works
- Needs
- 1. Brief gate
- 2. Build: work/<item>/04-prototype/index.html
- 3. Design review
- 4. Check
- 5. Gate: walkthrough, review notes, choice
SKILL.md preview
---
name: build-prototype
description: Use when the user wants a prototype, mockup, clickable demo, design options or "something to show" for an item with approved behaviour trees. Step 4 of the pipeline - builds one self-contained clickable HTML file with two or three hypothesis-led design variants, where every tree branch can be demonstrated in every variant, and proves that coverage with the checker.
---
# Step 4 · Clickable prototype with variants
The prototype lets stakeholders *feel* the behaviour trees before engineering starts, and it
settles the PRD's prototype decision by putting two designs side by side. It must show every
branch, including errors and edge cases, in every variant, not just the happy path.
Read first: the approved trees in `work/<item>/03-trees/`, the PRD (especially §2, §5, §6.2
and §6.3), `../../reference/phases.md`, `../../reference/prototype-craft.md`, the workspace's
`DESIGN.md` (the product's design system) and `context/writing-style.md`. Start from the shell `../../templates/prototype/index.html`; the worked example
`../../examples/price-alerts/04-prototype/index.html` shows a finished prototype built on it.
## Needs
Before starting, run `python3 .pm-harness/pm_check.py needs build-prototype` and confirm each tool
answers (preflight in `../../reference/connectors.md`).
- `design-source` · optional · the design system behind `DESIGN.md` and the current screens of a
flow being changed; without it, `DESIGN.md` as it is, or a neutral and provisional system
- `artifact-sharing` · optional · sharing the prototype for review (the `publish` skill)
## 1. Brief gate
Before building, show the PM a five-line brief and wait for approval:
- **Decision:** the trade-off from PRD §6.3, both sides named.
- **Variants:** two by default, each with a one-line **hypothesis** and its **trade-offs**. A
third only when it tests a genuinely different hypothesis, never a cosmetic one. An
`Enhancement` may use one variant (the change) with a `singleReason` saying what it is
compared against.
- **Screens:** the screens each variant needs; which are shared and which differ.
- **Scenarios:** every `while` state and `if` condition from the trees that the scenario
controls will switch.
- **Fidelity:** by phase (`phases.md`); MLP prototypes use the real design tokens and copy.
- **Design source:** `DESIGN.md`. If it is still the blank template and a `design-source`
tool answers, offer to fill it first, as `setup` does (Figma variables, a brand guide in
Google Drive, or the app's theme files), with the PM approving the values; never fill it from
the prototype. Otherwise say "neutral and provisional".
- **Current screens:** if the item changes an existing flow, read today's screens from the
`design-source` tools (Figma frames, screenshots in Drive) so the variants start from what
users see now; say so if none could be read.
## 2. Build: `work/<item>/04-prototype/index.html`
Copy the shell to `work/<item>/04-prototype/index.html`. It already has the phone frame, the side
panel and the **PM Harness runtime** (`<script id="pm-runtime">`), which runs the variant
switcher, deep links, the coverage panel and review notes. Leave the runtime exactly as it is,
so every prototype behaves the same and the checker can rely on it. You write four things:
1. **Screens,** inside `.phone`: each distinct state is an element with `data-screen="<id>"`;
one is visible at a time and navigation happens through the product's own buttons. A screen
that differs by variant is written once per variant with the **same id** plus
`data-variant="<id>"`; shared screens have no `data-variant`. Same id means switching
variants keeps the reviewer on the equivalent screen.
2. **Variants manifest** (`<script type="application/json" id="prototype-variants">`): the
decision, and for each variant an `id`, `label`, `hypothesis` and `tradeOffs`. Ids are short
kebab-case words; avoid `settings`, `sidebar`, `customize`, `upgrade` and `downloads`, which
claude.ai links reserve.
3. **Coverage map** (`<script type="application/json" id="tree-coverage">`): every `then` and
`and` line of every tree, mapped to the screen that demonstrates it and a `demo` that puts
the prototype into that state:
```json
{ "trees": { "functional/price-alert-creation": [
{ "line": "then the price alert is saved as active", "screen": "alerts", "demo": "create-ok" } ] } }
```
`screen: null` is allowed only with a `reason` (backend-only or "nothing happens" outcomes).
The screen must exist in **every** variant.
4. **Product code,** in the last `<script>`: scenario toggles in the side panel for every
`while` state and `if` condition in the trees (changing one must change what the product
does), and one call to `PMH.start({start, reset, render, demos})` with the starting screen,
a reset, a render function that fills a screen from state, and one demo per coverage line.
Navigate with `PMH.show(id)`, write to the event log with `PMH.log(text)`, find a part of a
variant's screen with `PMH.part(screen, class)`, and call `PMH.userAction()` when a
scenario control changes.
Rules: follow `prototype-craft.md` (adapted from Impeccable): `DESIGN.md` tokens become CSS
custom properties for the product screens, the screens are designed for a task (Operate mode),
variants differ in their hypothesis rather than decoration, and none of the tells in its refuse
list appear (no emoji or symbols as icons: draw them as inline SVG). Use the exact messages from
the trees in every variant, and mark sample data. Deep links look like `index.html#guided--set-alert--err-full`
(variant, screen, demo): plain names, so they also work in a Claude artifact link.
## 3. Design review
Before the PM sees it, review every variant in play against `prototype-craft.md` §7: score the
ten heuristics, check cognitive load, go through the craft floor, the harden list (the PRD's
markets and languages: right-to-left and longer translations) and the refuse list, then rank
findings P0–P3. Fix every P0 and P1, and write the scores, fixes and what remains to
`04-prototype/design-review.md`. The review covers the product screens, not the side panel. For
an MLP, P2 findings are fixed too.
## 4. Check
Run `python3 .pm-harness/pm_check.py prototype work/<item>/03-trees work/<item>/04-prototype/index.html`.
It fails if the variants manifest is incomplete, a tree line is missing from the coverage map,
a screen is missing from a variant still in play, the PRD and manifest disagree about the chosen
variant, or an amendment is malformed or still open. Then open the
file in a browser and click through every coverage line in every variant; the checker proves
structure, not that the design works.
## 5. Gate: walkthrough, review notes, choice
1. Walk the PM through the Journey tree in each variant, then any branch they choose.
2. Record every piece of feedback in `work/<item>/04-prototype/amendments.md`: the PM's,
artifact comments sent to Claude, notes copied from the review card, and prototype feedback
from meetings. Then run the `review-prototype` skill to classify and resolve each one. **If
feedback changes behaviour, the PRD and trees change first.**
3. Ask the PM to choose: **one variant**, a **merge** (named parts of each, recorded as
amendments and rebuilt into one variant), or **both as an experiment** (PRD §7 gets an
Experiment block, and the tickets include the experiment flag and analytics). Record the
choice and the reason under PRD §6.3 (`**Chosen at the prototype gate (date):** …`), and in
the decision log if it is durable.
4. **Archive the others.** Set `"chosen": "<variant id>"` in the manifest. The other variants
stay viewable, labelled archived, but are no longer checked or maintained: from now on only
the chosen variant must demonstrate every outcome, and review notes apply to it. (For an
experiment, leave `chosen` out so both stay complete.)
5. The prototype is approved only when the check passes with no open amendments. Then set
`stage: prototype` in `01-idea.md` and offer the `create-eng-tickets` skill. If the team
uses Figma for final design, say which screens of the chosen variant a designer should take
forward. If a Figma tool is in `design-source`, offer to put those screens into a Figma file;
it writes to an external tool, so only after the PM approves.
**Sharing it:** stakeholders can click through it as a Claude artifact (`publish` skill,
"Prototype"), where **Comment on this screen** sends their notes to Claude; or open the file
from disk, where the review-note card copies an amendment to paste in.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · Mosin112/pm-harness | 100 | MIT |
| allemaar/open-skills | 90 | Apache-2.0 |
Database snapshot: 13.11.2026 · package version f8a6ae0abe6c (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
- 100interactive-mockup
Produce two or three genuinely distinct design directions as static HTML, let the user choose, then build a working, self-contained offline HTML/CSS/vanilla-JS prototype by strictly grafting interactions onto the chosen direction. Use when asked to mock up, prototype, explore… - 100ai-prototype
Build a single-file, clickable HTML prototype of a UI screen or flow, following the design directions given in the request. Use when the user asks to prototype, mock up, or sketch a UI (e.g. "/ai-prototype order list, dense, neutral palette", "mock up the settings page"). - 90spectre-prototype
Create one self-contained HTML prototype to resolve ambiguity, validate flows, or render UX before planning. Use for prototype/mockup/preview requests and UX Stage 1→2; not for production code, multi-file apps, scope, or planning. - 90spectre-prototype
Create one self-contained HTML prototype to resolve ambiguity, validate flows, or render UX before planning. Use for prototype/mockup/preview requests and UX Stage 1→2; not for production code, multi-file apps, scope, or planning. - 90prototype
Build a throwaway prototype to answer one design question – a self-contained HTML file for a logic/state question, or several radically different UI variants switchable in one file. Use when a UX or domain question cannot be settled on paper, and in /feature or /implement when… - 100arn-spark-clickable-prototype
This skill should be used when the user says "clickable prototype", "arn clickable prototype", "interactive prototype", "test interactions", "validate UX", "user journeys", "test navigation", "make it clickable", "prototype interactions", "test the prototype", "build the…