A full-bleed poster: generative art, one sentence, two buttons. Four numbers you can click, then the buying journey as a metro map whose stations open the screens.

The classic three-column docs page: nav tree left, page in the middle, on-this-page right. Quiet and predictable; the visual summary is a strip of four key facts.

The experiment as a newspaper front page: the latest change is the lead story, numbers sit in the rail, a ticker rolls the small news. Serif, columns, dense.

No hero, no prose: the experiment's folder tree is the navigation. Every leaf is a page or a screen, so developers and designers read the same map.

The thing itself, big and tilted on a brand-coloured stage, like a product shot. Three bold facts and two buttons beside it; the six sample cases as chips underneath.

A comic strip carries the whole idea before a single rule is stated: who gets the receipt, when, and why it must not change. Three numbered take-aways follow, each a link.

An isometric exploded drawing shows the feature as a stack: one order snapshot, one component, three outputs. The four real build steps sit underneath as a strip.

A progress header and six steps. Each step pairs one action with a small picture of what you should see, and a box to tick when you see it. The header fills up as you go.

The tutorial is a conversation. A guide gives one instruction at a time; you answer with a reply button, which reveals the next message. Checkpoints fill in the side rail.

A dark, code-first lesson for developers. A rail of numbered lessons with times; each lesson is one command, its output, and what to notice. Ends by breaking a rule on purpose.

~/im-web-prototypesbun install
✓ 412 packages installed
✓ commit gate on (.githooks)

~/im-web-prototypesbun scripts/new-prototype.ts baseline price-test
✓ copied 118 files → src/routes/prototypes/price-test
✓ rewrote routes and PROTOTYPE_ID
✓ regenerated route tree and agent rules

~/im-web-prototypesgit commit -am "Use the receipt's VAT"
✗ fallow: price-test imports features/receipt
~/im-web-prototypesbun scripts/copy-from.ts receipt prototypes/price-test vat.ts
✓ copied vat.ts → -lib/from-receipt/
✓ noted source commit in copied-from.json
~/im-web-prototypesgit commit -am "Copy the receipt's VAT"
✓ format · lint · fallow: all clear

The whole task on one ruled index card: what you need on the left, three steps on the right, the menu drawn as you will see it. Nothing to scroll past.

A docs-shell page whose lead is a yes/no flowchart: most readers stop at their first “yes”. The command only appears at the end, for those who need it.

# from the repository root
$ bun scripts/copy-from.ts features/receipt prototypes/baseline receipt-page.tsx
copied receipt-page.tsx, receipt.tsx, types.ts, vat.ts
wrote  prototypes/baseline/-lib/from-receipt/copied-from.json

A dark, terminal-flavoured page where the command is the headline. Every word of it is labelled in place; below come the three results and the four ways it can fail.

A real path, cut into coloured segments, is the first screen; under it a sticky row of names jumps into a three-column dictionary: name, what it means, where you’ll meet it.

Dense and tool-like: all 36 Baseline decisions as a waffle you can click, then one line each under a sticky filter bar with group chips, counts and live search.

Split screen: a dark adjacency matrix answers “may A import B?” at a glance and explains any cell you tap; the light side lists each folder as a card.

An illustrated essay: the metaphor picture first, then a centred serif column with a drop cap, notes in the margin and one pull quote. On a phone the notes drop into the text.

Starts from what people wrongly believe. One myth fills the first screen, struck out beside its fact; smaller pairs follow; leftover questions fold into an accordion.

An explanation you operate: a sentence with live numbers, a network that tangles when you allow cross-imports, and the count of ties that a change could break.

No diagram and no prose: the page is a wall of live mock-ups, one per situation, each with its own tick list. Filter chips pick a customer.

An engineer’s data sheet: a blueprint-blue spine holds the facts, and four tabs hold one view each. It opens on the measured drawing.

const canPay = termsAccepted 1
  && (buyer === 'company' || waiverAccepted) 2

<PayNow total={order.total} 3
        onPay={() => send({ type: 'PAY' })} /> 4

The screen itself leads, with numbered markers; hover a number to light its part. Below, a three-frame film strip shows the component change state.

A dark poster of right and wrong pairs, each with its reason, ending in a one-click quiz. The component is the smallest one there is: a price.

One sheet of paper, like an architecture decision record: a stamp, four key facts in a ruled strip, the options as three columns, then consequences.

The first screen is the change itself: grey past on the left, coloured present on the right, with the old price struck out. The rule’s wording follows as a word diff.

A story told as a timeline: the question, the chat where it was answered, the edit to the rule. A side panel keeps the outcome in view the whole way down.

A cockpit for the facilitator on test day: the agenda as a Gantt bar, a ticking checklist with progress, keys and customers at hand. Built to be glanced at, not read.

A print sheet on a cutting mat: big serif task cards for the participant, handwritten stickies with what to watch for the facilitator. The stickies don’t print.

The test is laid out as the buyer’s journey: stages across, rows for the task, the screen, what to watch and the rules in play, with an expected-mood line on top. On a phone it folds into one column per stage.

A poster: the layered diagram takes the whole first screen, four short floors read left to right under it, and a dark strip ends the page with what is checked before every commit. On a phone the drawing becomes stacked HTML layers.

An explorer instead of an essay: a list of experiments down the side, a network and an import matrix in the middle. Pick one and everything else fades; three boxes say what it may use, what it copied and what is refused.

Architecture told as one request, drawn on blueprint paper with a title block: a sequence diagram of how a receipt becomes a PDF, numbered steps with the files involved, and the bug that shaped it crossed out in red.

The V69 drawing blown up to fill the first screen: the sheet in the middle, every part lettered and named on both sides. A lettered key with links follows. On a phone the letters sit on the sheet and the key becomes the page.

The receipt stays pinned while short steps scroll past; each step dims the sheet and lights up one lettered part. Reads like a guided walk from the top of the paper to the bottom.

A dark desk, the receipt on it, pulsing letters to tap. One explanation at a time in a side card, next and previous to walk through, dots to show what you’ve seen. “Show all names” labels every part at once.

The receipt as real, selectable text, read like a proof on the desk: lettered labels in the margin, and highlighter in four colours showing which decision governs each phrase. Press a colour to isolate it.

The page is a kanban board and nothing else: three columns, one card per fact from status.md, and chips that dim what isn't for you.

A serif logbook: a strip of days as the visual summary (bar height = changes that day), then one dated entry per change, newest first, typed New, Changed or Fixed.

A dark dashboard of tiles: four big numbers, a waffle of decisions, bullet bars for how far each area has come, and a screen inventory with status dots. No prose at all.

First screen: every word placed where it lives in the repository, as clickable chips on a silo diagram. Then a classic dictionary with an A–Z rail down the side.

A deck to learn the words: each card shows a tiny picture of the idea; tap to flip to the definition. Built for a newcomer's first hour, not for looking things up.

The page opens on the exact message you got, in a terminal, with tabs for the four ways a commit is refused. Below: what it means, how to fix it, how to check, in three columns.

For people testing the prototype, not coding it. A fishbone of the four usual causes leads into an accordion of symptoms, each opening to cause and fix.

A Venn diagram is the whole story at a glance; a rule-by-rule table under it gives the proof, with the differing rows tinted. On a phone the Venn becomes three stacked boxes and the table becomes cards.

A poster-like face-off: the two checkouts as real mock-ups, left and right of a big VS, with numbered yellow marks on what differs and a switch that fades everything that's the same.