---
name: create-page
description: "Use when the answer is more than a few paragraphs, or lays out steps, options, a comparison, or figures. One self-contained HTML page to scan, print, send on, or use. Forms: FAQ, timeline, how-to, checklist, itinerary, comparison, dashboard, data explorer, scorecard, brief, memo, case study, explainer, recommendation, wireframe, whiteboard, or a small working tool."
---

# Create page

One self-contained HTML file that a reader can open, keep, print, send on, and in a few cases use. Twenty-one templates cover the kinds of page people actually ask for; each names a set of slots and the intent behind each one, and all of them share the look, the method, and the refusals below.

The page is the answer. When a reply would be long, structured, or worth keeping, a page beats a wall of chat: it can be scanned, linked into, printed, and handed to someone who was not in the conversation.

## Choose the template

Read the row that fits, then read that template's `template.md` in full before writing anything. Paths are given because the file listing you were handed may be truncated: open them directly.

| Template                                                                      | Reach for it when                                                                                                                                        |
| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Briefing memo                          | Something with real stakes has to be decided, and the situation, the options, and a recommendation belong on one page before anyone commits.             |
| Case study                                | A situation like the reader's played out start to finish, and the point is to learn from it or to show that an approach works.                           |
| Checklist                                  | A process is about to run where forgetting one step is expensive, and every item wants to be grouped, tickable, and printable.                           |
| Comparison matrix                  | Several options need measuring on the same attributes side by side, before deciding what matters.                                                        |
| Recommendation with criteria | The winner is wanted along with the arithmetic: named criteria, stated weights, scored options, and what would flip the answer.                          |
| Dashboard                                  | A period has ended and someone has to know how it went: the figures with what to compare them against, and the thing the headline hides.                 |
| Data explorer                               | There are more rows than anyone will read and the rows are the point: the whole set, what it turns out to say, and a grid to sort, filter and take away. |
| Explainer                                  | A mental model of a concept, a system, or a topic is needed before deciding or digging deeper.                                                           |
| FAQ                                              | The same questions keep arriving about one topic, and each wants answering once, in a block that can be found, skimmed, or sent.                         |
| How-to guide                                  | Something has to get done in order, with the tools listed, the traps marked, and a way to know when it is finished.                                      |
| Itinerary                                  | A destination and a span of days want planning into mornings, afternoons, and evenings that can be followed from a phone.                                |
| One-pager                                  | A project, a program, or a change is being proposed and needs one page that earns the next meeting.                                                      |
| Pros and cons                                | The question is torn on one option or between two, and each side deserves its strongest case, weighted for this situation.                               |
| Recommendation guide            | A product, a tool, or a vendor is being picked, and one page should name the pick and show its work.                                                     |
| Scorecard                                  | One vendor, tool, candidate, place, or plan is in front of the reader and wants grading across the dimensions that matter, evidence beside each.         |
| Should I…?                                  | A should-I, is-it-worth-it, or do-I-need question wants a plain answer that shows what it turns on.                                                      |
| Timeline                                    | Change over time is the explanation: the order of events says why things are as they are, or what happens next.                                          |
| TLDR brief                                | The research is done, and the reader wants only the takeaways, on one screen.                                                                            |
| Tool                                            | The answer is a function rather than a fact: a calculator, converter, checker or planner that opens with a real example already in it.                   |
| Whiteboard                                | The material has two dimensions of its own and an order throws them away: a wall of sorted notes, a plan of somewhere real, things placed on two axes.   |
| Wireframe                                  | An interface is being proposed or argued about, and the fastest way to settle it is a sequence of frames that each prove something.                      |

When two rows both fit, the tie-breaker is what the reader does next. A page that ends in a decision is a brief, a should-I, or a recommendation; a page that ends in an action is a how-to, a checklist, or an itinerary; a page that ends in understanding is an explainer, a timeline, or an FAQ; and a page the reader keeps open and comes back to is a tool, a whiteboard, or an explorer.

Three of these are a family of their own, in that the page does something rather than only saying something: a wireframe draws a proposed interface, a whiteboard is a surface the reader moves around, and a tool computes. On all three **the page is the thing** -- there is no prose column, no opening paragraph and no closing section, because a drawing under three paragraphs is an essay with pictures in it and the paragraphs are the part nobody wanted. A name, one line, the artifact, and a line of provenance under it. They obey every rule below, including the one about the network, and each says in its own `template.md` what that costs it.

When none of them fit, say so and write the page anyway, using the nearest template's slots as a starting point and this file's method as the rule. A page whose shape had to be invented is a better answer than the wrong template filled in obediently.

## Make the page

1. Read the chosen template's `template.md` in full, and its `idea.json` for the page's stated purpose.
2. Read the two examples in that template's `examples/` whose situation is nearest the user's. Each has a sidecar `.json` with a design note saying what that example chose and why; read the notes, not only the pages. Never take the first example as the target.
3. Write a three-line brief before any HTML: who reads this and what they will do next, the one thing the page has to settle for them, and the one distinctive move this page makes that the two examples did not.
4. Copy `starter.html` to `output/<slug>.html`, set its `instrument:idea` meta to the template's name, and paste the template's `main.html` inside `<main>`. The starter carries the tab icon, the skin, the fonts, the icon set, and the page behavior, each inside a `shell:start` … `shell:end` pair; leave those regions as they are, and everything under `<main>` is yours. Your own CSS goes in the gap the starter leaves between them.
5. Fill the slots with the research. Sections may be reordered, merged, renamed, or rebuilt, but every intent the template names must be answered somewhere on the page.
6. Check it against the refusals below and the template's own, open it, and look at it once at a laptop width. Fix what you see, then stop.

Research before you write, and write from what you found. A page whose facts came from the model rather than from a source is the failure this whole skill exists to avoid.

## What stays fixed, and what must vary

Fixed, because every page shares one look: the skin block in the starter, the type stack, the palette with brand green as the only saturated color, the spacing scale, a single self-contained file, and a provenance footer.

Free, and expected to differ between two pages made a day apart: the layout and column count, the density, the register, the components, the way a slot is realized, and any interaction, which must be progressive so the page reads with scripts off. Each template names what varies most in its own case.

The look follows the reader's system theme, and you never choose between them. Write the page once against the tokens and both come out right: a step on a ramp names distance from the paper rather than a lightness, so 25 is the faintest wash and 950 the darkest ink in either theme, and what changes is which end of the spectrum each lands on. The saturated middle, 400 through 600, holds still in both. That is the whole rule for white: it rides the middle and nowhere else, because every other step moves out from under it. Never hand-pick a ground for the page, and never write a `dark:` variant; `bg-background`, `bg-card`, `bg-muted`, `text-foreground` and `text-muted-foreground` already say what you mean. The one exception is a terminal or code listing, which is a well cut into the paper and keeps its own colors in both themes: `bg-code` with the four `text-code-*` inks.

`pnpm check:contrast` reads both palettes out of the skin and every page for what sits on what, so a page that fails WCAG AA in either theme fails the build. It is the reason nobody has to open the page twice.

The starter also carries three behaviors every page gets, and none of them need doing by hand: every external link wears the icon of the site it points at, footnote markers and their notes link both ways and light up when jumped to, and the page prints with sane margins. A page wider than a portrait sheet adds `@page { size: landscape }` in its own style block.

A page's own logic is one `<script type="module">` at the end of `<main>`, never a plain `<script>`. The starter's last script keeps a copy of the page for sharing as the parser reaches it, and a module script runs after that, so a shared copy carries the markup as written rather than as the script changed it. Module scripts do not share top-level names, so keep the logic in one, and attach listeners in it rather than through `onclick` attributes.

## Refusals

A page that could be any of the examples with the words swapped. A thing that lives at a URL named in plain text, or a link whose text describes the destination rather than naming the thing. Any image whose `src` is a URL or a relative path rather than inline data, any sibling file, and any relative fetch: the file has to open from a USB stick, arrive as an email attachment, and be served from a share host, and only one of those has an origin. A file over about 1.5 MB, or an inline image over 200 KB.

**What a page may load, and the test it has to pass.** Most pages load nothing beyond the starter's fonts, icon set and Tailwind build, and that is the right default. Where the material is a dataset rather than an argument, a page may also load one of the libraries in `check-ideas.ts`'s `ALLOWED_SOURCES`, pinned to an exact version. The test is not whether it loads, it is what happens when the load fails: **open the page with the network off and every number, name, place and finding is still there, in the HTML.** A library may add motion, precision or scale to something already on the page; it may never be the only copy of a fact. A chart carries its own table. A map's container carries its own list. A figure fetched at open carries the value it was written with, and the date. A page that goes blank, empty or meaningless offline is the refusal this rule exists for, and a template that reaches past the list has to say in its own `template.md` why its document kind needs it.

Each template adds the refusals that only bite in its own case.

## Honesty about research

Say on the page what it rests on and when it was read. Where two sources disagree, say so and say which one the page followed. Where a figure is an estimate, a quote, or a reconstruction rather than a published number, label it as one. Where the research is thin, the page says so in its footer rather than performing certainty: a thin honest page is useful, and a confident invented one is worse than nothing, because a reader will act on it.

Numbers are the easiest thing to invent and the hardest for a reader to check. A page carries a figure only when the prompt, a source, or arithmetic over shown inputs gave it. Scores use coarse scales — letters, a few dots, a word — unless every input is on the page, and never a decimal that implies precision the research does not have.

## References

Vocabulary, not layout. Read the one whose form is in play, not all of them.

- [`references/patterns.md`](/discover/create-page/references/patterns.md) — the recurring elements: kickers, status pills, step circles, icon lists, emphasis cards, code and terminal blocks, quoting, evidence footers, and how a block wider than the column behaves.
- [`references/charts.md`](/discover/create-page/references/charts.md) — stat tiles, bar rows, meters, sparklines, timeline bars, and the honesty rule for drawing a number.
- [`references/diagrams.md`](/discover/create-page/references/diagrams.md) — when HTML beats SVG, the SVG kit, swimlanes, parallel routes, and generated geometry.
- [`references/interaction.md`](/discover/create-page/references/interaction.md) — answer forms, runbook ticks, click-to-enlarge, details/summary, and the rule that interaction may orient but never gate.
- [`references/images.md`](/discover/create-page/references/images.md) — when a picture earns its place, how to size and inline one, and what to draw when there is no photo to use.

Each template also has a `patterns.md` beside it, for the vocabulary only that document kind uses.

# Whiteboard

One self-contained HTML page whose subject is an arrangement. The content sits on a surface bigger than the screen, at positions that mean something, and the reader moves around it: drag to pan, pinch or scroll to zoom, click a small map to jump. Not a diagram of boxes joined by arrows, and not a slide. A place.

Every other template puts things in an order. This one puts them in a **place**, and the argument is what the placement makes visible: what is next to what, what is far from what, what clusters, and what would not sit anywhere.

## When to reach for it

Reach for it when the material has two dimensions of its own and flattening them into a list throws the interesting part away. Three shapes come up over and over:

- **A wall.** Many small things sorted into groups by hand: survey answers, quotes, ideas, findings, cards from a workshop. The grouping is a judgment, and the reader should be able to argue with it by moving something.
- **A plan.** Something that is already spatial: a floor, a site, a garden, a room, a route. Distance on the page is distance in the world, and the questions worth asking are questions about distance.
- **A map.** Things placed against two measured axes: cost against urgency, effort against value, price against range. **A board is a scatter plot whose points are legible.** Twenty labeled cards you can read beat twenty dots and a key, and once they are cards you can also ring a group, draw an arrow between two of them, and cross one out, which is the part no chart does.

"Put it all on one board", "lay this out", "where does everything go", "what's near what", "cluster these", "map this out" are the phrases. Reach for it unprompted when a page you are writing keeps saying "meanwhile" and "at the same time", or when a list you are making has an order you keep having to apologize for.

Do not reach for it when the content is a sequence with one dimension: that is a timeline, and a timeline is easier to read. Nor when one axis is a real quantity and the other is a count, which is a chart and belongs on a [dashboard](../dashboard/template.md); the board earns its place when both axes are readings **and** the labels have to stay legible. Do not reach for it for boxes joined by arrows, which is an explainer's diagram and belongs in the column with the prose. Do not reach for it when the reader wants to filter and sort rather than to look, which is a [data explorer](../explorer/template.md). And do not reach for it because a board looks impressive: **if you cannot say in one sentence what position means, there is no board here**, only a list that has been scattered.

## The shape

**The page is the board.** It takes the whole window and there is no prose column on it, because a board read through a letterbox under three paragraphs is a picture of a board. There are two slots and one of them is a line.

- **A title bar.** A name, one line, and the legend. The line has a job the other templates' openers do not: **it says what position means**, because a reader who does not know that is looking at a picture. The legend is what color, size or shape say, in as few words as it takes.
- **The board.** Everything else.

The two things a prose section used to carry go onto the board itself, which is where a person would have put them:

- **What the arrangement says** is written in marker, next to the thing it is about. "Not one shopkeeper in this ring" beside the ring is a finding a reader can check by looking down; the same sentence in a section below the board is one they meet three screens after the evidence, having lost the ring. Two to four of these, each anchored.
- **Where this came from** is a card in a corner of the board: what the placement rests on, what is measured and what is judgment, what is missing, and what the board is not a picture of.

## What varies here

Free, and expected to differ between two pages made a day apart: the size and aspect of the board; whether it has regions, axes, lanes, or nothing but placement; whether cards are draggable; what appears only at higher zoom; the density; how much marker there is; and the kind of thing a card is, which may be a sticky note, a desk, a photograph, a log excerpt, a small chart or a quote, and may differ card to card on the same board.

## The rules that make a board work

**Position is the whole claim, so state it and then honor it.** A wall's regions are a judgment, and the page should say so. A plan's distances are measurements, and a plan whose blocks are sized for the layout rather than for the building looks identical and means nothing, which is worse than a table because it looks authoritative. A canvas's axis has a scale, and a card nudged along it for room is a lie in the same units as the truth.

**DOM order is reading order.** Printed, the board collapses to exactly the sequence the cards are written in, and that is the only thing a reader with a sheet of paper gets. So write the cards grouped the way you would talk through them: a region's heading, then that region's cards, then the next. Positions can be in any order and the file will still work, which is exactly why this has to be a rule rather than a consequence.

**The board is on the page, not in the script.** Cards are real HTML with their coordinates in a `style` attribute. With the script gone the stage is an ordinary scrolling box at full size and every word is still there. Nothing on a board may exist only as a string in JavaScript.

**Zoom may reveal detail; it may never hide a fact.** `data-from` is for a desk's occupant, a room's capacity, a second line under a label. If the page's argument depends on something, it is legible at the size the board opens at, or it is written in the prose below.

**Say where what the reader moves is kept.** Which is: in that browser, and nowhere else. The file is unchanged, so a copy they forward arrives arranged the way it was written. That is a fine thing for a board to offer as long as nobody is surprised by it, and it is the reason `data-drag` belongs only on cards whose position is an opinion. On a plan, whose positions are measurements, a card the reader can move has broken the page's only claim.

**Draw on it.** A board that is cards on a grid is a slide with panning. What makes it read as a board is marker over the top: a ring round a group, an arrow from a thing to what it causes, a heading in handwriting, a job crossed out. Every stroke is `data-ink`, drawn by the script into a box you placed, and every one is commentary rather than content -- it carries `data-region`, so it does not print and does not survive the script, and nothing on the board may depend on it. **Anything you would be sorry to lose is a card, not a stroke.**

## What it may load, and what has to survive without it

Nothing beyond the starter's fonts, icon set and Tailwind build. The pan-and-zoom is about two hundred lines of pointer handling in the page, and the canvas libraries that would replace it are the wrong trade twice over: they are megabytes against the whole page's kilobytes, they need React, and they render a scene from a JSON blob, so with the library absent the reader gets a blank rectangle instead of a board. The rule this family runs on is that a library may add motion or scale to something already on the page and may never be the only copy of a fact, and a canvas SDK fails it by construction.

Small drawings on the board are inline SVG. An image is inline data, like anywhere else.

## Refusals

A board where position means nothing, which is a list with extra steps. **Prose sections before or after it**; the page is the board. A legend that is missing, or that explains the colors and not the axes. Boxes joined by arrows. Content that can only be reached by zooming or dragging. A plan drawn out of scale. A card nudged off the value it claims so it would fit. A board with no marker on it saying what it shows. A reader who has to drag before they can read. Cards generated in script, so the page is blank without it. A fact that lives in a stroke of ink. Draggable cards on a plan. Persistence that is implied to travel with the file. More than about a hundred cards, past which nobody is reading a board, they are scanning a dataset and should have been given a grid.

## Honesty about the arrangement

Say what the placement is drawn from, because a board's authority is entirely in its coordinates. A plan traced from a real drawing is a claim about a building; one laid out by eye is a sketch, and the two look the same on screen. Where a card's position is a judgment, say that it is, and let the reader move it if moving it is cheap. Say what is not on the board, since a board reads as complete in a way a list does not: the empty part of a board looks like an absence of things rather than an absence of research. And where a card carries a number, the same rule holds as everywhere else: it came from the prompt, a source, or arithmetic over what is shown, or it does not appear.
