Ideas, pulled at random
and actually built.

What it is

A four-level, top-down film-noir shooter that runs in a browser tab. Nine days of rain, one night to make it simple again: Detective Ray Calloway, framed for his partner's murder, works his way from a subway platform up fifty-four floors to the man who set him up.

The two moves that matter are the ones the idea was really asking for. Bullet time on Shift drains an hourglass and refills on kills. Shootdodge on Space throws you sideways through the air, in slow motion, still firing — and pays triple. Four weapons, painkillers instead of regenerating health, and hand-drawn comic panels between chapters.

Everything is generated at runtime. There is not one image, sound or font file in the project: the gunshots are synthesised noise bursts, the rain is a filtered noise loop, the comic panels are painted with canvas paths and a halftone screen, and the levels are lists of rectangles.

Mouse and keyboard · no install · no account

Notes from the build

• The lightmap was the whole game. Every level light casts real hard shadows, built from the silhouette edges of the wall rects. Doing that per frame cost 5.6 ms in the nightclub and dragged the game to 24 fps. Lights and walls are both static, so each light's shadowed falloff is now baked once into its own texture and blitted — 0.3 ms, and the frame came back.
• Paint bright, then take the light away. A multiply lightmap can never push a surface past its own colour, so the first pass at the art was unreadably black — the floors had been painted at the brightness they were meant to end up. Repainting every surface at "fully lit" and adding a second additive pass is what makes wet concrete look wet.
• Shots that vanished. Bullets spawned at the muzzle, 22 px ahead of the player. Stand against a crate and that point is inside the crate, so every round died on the frame it was fired — a boss fight that could not be won. Tracing the first step from the shooter's centre makes line of fire and line of sight agree exactly.
• An unwinnable state. Testing found a run that emptied every weapon with hostiles still standing: no ammo, no way to make more, no way out. Calloway now finds a spare clip in his coat when everything is dry.
• Enemies path, they don't cheat. A* over a dilated 40 px grid with corner-cut prevention and string pulling, repathed on a stagger. Goons hunt your last known position, flank, and duck behind cover when they are hurt.
• The board is ours. Scores go to a small PHP endpoint on the same webspace — fixed schema, key-gated, atomic writes, and a data directory the web cannot reach. A client can add a row; it can never wipe the board.

What it is

An app that interviews you. One question at a time, 120 of them across ten chapters — Origins, Childhood, Family, Places, Love, Work, Turning Points, Beliefs, Now, Later — each written to pull a scene or a person out of you rather than a yes or a no. Answers accumulate into a book you can read, reopen and hand to someone.

Rings are sets of questions you switch on and off in any mix. The Core is thirty questions, about two hours, the short book a stranger would need; Deeper and The Long Way add ninety and sixty more, and a future pack is just another ring. Time left is measured at your own pace once it has seen you write a few. Export a printable HTML book, plain Markdown, or a JSON backup that restores on any device.

The note on the idea said "iOS app or better platform independent". It is one Expo codebase: the web build linked below is the same app, and the native builds are an eas build away.

Web build of the Expo app · works in a phone browser · nothing ever leaves the device

Notes from the build

• Tested like a phone, not a terminal. The web export was driven in Chromium emulating an iPhone 13: answer four questions, steer the question order from a chapter, weave, edit, export the book, download a backup, erase everything, restore it. The run is scripted and passes against the live URL with zero console errors.
• A race between erase and restore. Erase used removeItem; every other write was debounced. The harness caught "Restored, 4 answers folded in" followed by an empty store — the erase landed last. Every change now goes through one serialised write, and the store flushes when the app backgrounds.
• Alert.alert does nothing on web. Errors were being swallowed silently in the browser build. A tiny notify() wrapper routes to window.alert there.
• Subpath hosting needs two things. Expo's baseUrl so the bundle resolves under /one-reader/, and an Apache rewrite so deep links like /chapter/origins reach the app. The fonts live under dist/assets/node_modules/ — a deploy that skips node_modules blindly ships a fontless app. It did, once.
• Borrowed a language. The first pass was paper-and-ink; on request it was re-skinned in the "Pop" language of another app on this site: neutral ground, one saturated Khroma-paired colour card per chapter with its partner ink, grotesk UI, pill buttons, an icon-only tab bar, light and dark twins following the system. The prose kept its serif.
• Runs on a phone now, detached. An Expo tunnel on :8098 is launched by a small PowerShell script that survives the shell that started it (and retries ngrok's flaky first handshake). Open it in Expo Go; no store needed.
• Built a backend, then deleted it. The first version had an AI "weave" that rewrote a chapter as prose through a proxy on this webspace. It worked, but it brought a server, a secret, a daily quota and a host quirk into an app whose whole point is that nothing leaves the phone. Cut on request; the app has zero network calls now.
• Not done on purpose: no App Store or Play submission. That needs an Apple account and a human signature; the repo is ready for eas build.

What it is

PureRef is the tool concept artists keep open beside the canvas: an infinite wall you throw reference images on, and almost nothing else. Tack is that, in a browser tab, MIT licensed. Drop or paste images — files, screenshots, a URL dragged from another tab — then move with snapping, scale about a corner, rotate with a knob, crop by dragging edges, flip, greyscale, write notes, marquee and group-transform. Ctrl P packs the whole wall into a tight rectangle.

Boards autosave to IndexedDB and keep the original bytes of every image. A board exports as one .tack file with the images inside, or as a full-resolution PNG. Installed as a PWA it works offline; nothing is ever uploaded, there is no account and no server.

The brief allowed a launch, so there is one: a social card, a launch/ folder with Show HN, Reddit, Product Hunt and thread copy ready to post, and a README written for the repo. Publishing to GitHub is the one step that needs a token this machine does not have.

Vanilla ES modules · one canvas · zero dependencies · MIT

Notes from the build

• Geometry in the gesture's own frame. Scaling about the opposite corner of a rotated, flipped, cropped image drifts unless every step is computed in the local frame captured when the drag began. Crop is stored as fractions of the natural size, so it composes with rotation and scale for free.
• Shelf packing was ugly; skyline is not. The first "pack" justified each row and left holes in sparse rows. The replacement is bottom-left skyline packing tried at eight candidate widths, scoring fill against the window's aspect. 150 items in 4 ms.
• display: grid beats hidden. The "Drop images here" hint stayed on top of a full board because its CSS display overrode the attribute. One global [hidden]{display:none!important}.
• A keystroke that opens a text field types into it. Pressing N created a note, focused its editor, and the "n" landed in the note. preventDefault on the keydown.
• Fit has to know about the toolbar. Fit-to-screen padded evenly, so a zoomed-to image's rotate knob sat under the floating bar and could not be grabbed. The top inset is now 100px.
• Big walls stay smooth with one mip. Every image over 1500px gets a ≤1024px ImageBitmap alongside the full one; the renderer picks whichever is closest to the on-screen size. 150 photos at 1800–3400px: 16 ms a frame while panning.
• Honest about CORS. An image URL from a site that forbids cross-origin fetches cannot be stored. Rather than a tainted canvas that breaks PNG export later, Tack says so and asks for the file.

What it is

A deck of cards to think with. Each card is a question to sit with, a mantra to carry, or a line from someone long dead. Swipe right to keep it, left to pass, tap to write a thought on it. 156 cards in eleven packs — Morning, Evening, Gratitude, People, Work & Craft, Body, Fears, Joy, Big Questions, Mantras, Quotes — any mix switched on.

Discovery deals cards you have never seen first, shuffled fresh each day; Routine deals the ones you kept, so the same few questions come round every morning. A quote opens every session. What you write lands in a journal by day; a JSON backup restores on any device and a Markdown export reads like a diary. Nothing leaves the phone.

The note said "sleek ass design" and "minimal color and silhouette design", so every card is one solid colour with a partner ink, one flat shape, and a serif. That is the whole visual system.

Web build of the Expo app · on the phone through Expo Go · all private always

Notes from the build

• The card sprang back after four pixels. On the web, a PanResponder drag was being terminated by a parent view asking for the responder, so every swipe snapped home. The harness traced the card's transform frame by frame to see it. onPanResponderTerminationRequest: () => false, and a 240px drag reads 240px.
• Swipes tested with a real mouse drag, not by calling the handler: mouse down, eight moves, up — the same path a person's thumb takes. Both directions, then the buttons, then the keyboard.
• A saved thought moves the deck on. The write sheet is a modal; when it closes the deck screen regains focus, sees which card was written on, and deals the next — without the sheet ever knowing about the deck.
• Discovery order is seeded by the date. A fresh shuffle every day, but the same order all day, so putting the phone down and picking it up does not reshuffle the cards under you.
• Tests wait for the debounce. Every write to storage is coalesced 250ms after the last change; a check that read storage 200ms after a tap read stale data. The harness now waits longer than the app does.
• Where the reload lands matters. Reloading a tabbed Expo web app returns to the tab in the URL, not the first tab. The persistence check now navigates to the deck explicitly.

What it is

You type what is on your mind. You get one to three short questions back, built on what you just wrote — never advice, never a summary, never a compliment. "Just tell me what to do" gets a question. Ten questions in, most people have said the thing they were avoiding, and it was them who said it. Socrates called it maieutics.

The rule is code, not a prompt: the server splits every reply into sentences and drops any that does not end in a question mark; one rewrite, then a fallback. Gemini flash-lite answers in under a second. The conversation lives in the tab; the only thing written to disk is a per-visitor daily counter so one person cannot drain the key. Four lenses — stuck, deciding, understanding, feeling — change only the first question. It replies in German if you write German.

This is the first project with a stage after publishing. Following introdote-2: a written concept with "the line", a researched neighbourhood with evidence from actually opening each page, a queue of three drafted comments that nothing can post without a human approving, and a ?stats=1 endpoint so "ten users" is a number, not a feeling.

~300 lines of JS · one PHP file · no account · nothing stored

Notes from the build

• The model will not stay in character; the filter does. Asked to "only ask questions", flash-lite drifts into a clause about itself within a few turns ("when I am only carrying your questions?"). The prompt now forbids self-reference, and the server keeps only sentences ending in "?" regardless. Zero statements reached the page in the walkthrough.
• Model roulette, again. gemini-2.5-flash-lite is gone for new keys; gemini-3.7-flash hung for two minutes; 3.6-flash spent its token budget thinking and returned half a sentence. 3.5-flash-lite answers in 900 ms. The endpoint tries three models in order.
• The neighbour that proves the point. The nearest existing tool ("Don't Ask Me", Show HN, 2 points) puts the chat behind a sign-in, charges for "no answers ever", and penalises giving up with reputation points. Only Questions has no account and no game; that is the positioning, found by opening the page.
• HN threads close. The best on-topic thread ("How do you learn with LLMs? e.g. socratic method") is 18 days old and past the comment window. Seeding has a clock; the plan says so.
• Reddit is a wall to scripts and fresh browsers alike. Every search returned the "Welcome to Reddit" page. Those two searches are handed to the human, with the exact queries.
• No PHP on the dev machine, so the walkthrough runs against the live endpoint: a real four-turn conversation including "just tell me" and a German turn, reload, copy, start over, the key gate.

What it is

A name comes up — Maya — with a question. Everyone except Maya says out loud what they think she will answer. Then Maya answers, and Maya taps whoever came closest. That person scores 1. If nobody came close Maya scores 2, so a safe, boring answer is not a winning move.

Three rounds, and they get deeper: Warm (top three sweets), Real (what money meant in the house you grew up in), Deep (what you feel guilty for even thinking). Between rounds the game stops and offers to end there. Whoever is on a card can skip it — no reason, no penalty — and that is rule four on the screen everyone reads before the first question.

The trick is where the exposure sits. Every other version of this points at one person and asks for a confession, which is an interrogation, and an interrogation gets you the shortest true-ish answer available. Here the four people guessing are the ones on the line and the subject is the answer key — with the last word on who actually knows them.

284 hand-written questions · 2 taps a card · works offline · no server

Notes from the build

• The deck is the product, so it was written by hand. The rule for every card: the answer has to be short, specific and guessable. "What is the meaning of life" is unguessable and therefore a dead card; "which of your parents are you more like, and in what specific way" is a game.
• Colleagues get two rounds, not three. There are 99 warm and 69 real cards tagged for work and zero deep ones, because none of those questions should be asked on a Tuesday by someone who writes your review. Rather than invent filler, the app counts what exists and says so on the setup screen.
• Winning by being unreadable is a different achievement. The first scoreboard crowned someone "Closest tonight" who had scored almost entirely from nobody guessing her. It now tracks both and the header says Nobody could read when that is what happened.
• Two players never see a "who here" card. 42 of the questions ask the subject to name someone at the table; with a couple there is only one candidate, so the pool filters them out before the deal.
• The deploy was lying. A 21 KB module landed on the server as 0 bytes while curl exited 0 and the script printed "all uploaded". deploy.mjs now re-downloads every file it sends and compares it — folding CRLF, and allowing for the cookie script lima-city injects into every HTML response — then re-sends anything wrong. It repairs one or two files on every run.
• Bakeoff, dropped. A model-vs-model arena got as far as a written concept before being cut in favour of this one. The costing survives it: a game-sized prompt bills about 20k output tokens once thinking is counted, so a flagship head-to-head is roughly 85¢ a go and Gemini-against-Gemini is free.

What it is

A library of questions instead of answers. Pick the situation you are actually in and get sixteen questions written for exactly that, in four movements of four: where you actually are, what you actually want, what is in the way, what happens next.

The order is the product. The thirteenth question only works because you answered the first twelve, and the last four are all dated and concrete on purpose, because the point of asking is to end up doing something. A flat pile of three hundred deep questions is worth nothing — which is why the ones you can already find are free.

The title is the navigation: Questions for ______, and the blank is the search box. Read a stack whole or run it one question at a time with nothing else on the page; star what bit and copy it out; send someone questions for when it went wrong instead of advice. A stack prints as sixteen cut-out cards, because the physical version of this is a box of categorised card stacks.

19 stacks · 304 questions · no account · works offline

Notes from the build

• Search has to bridge topic and situation. Nobody types "getting the first ten users" — they type marketing. Each stack carries the words people would actually reach for, so the topic finds the situation the stack is named after.
• The four movements are enforced, not suggested. Every stack is exactly 4 × 4, and the walkthrough asserts the movement of each card as it runs, so a stack cannot quietly become a list.
• Naming a view after a button. The run screen rendered as one enormous rust-coloured pill: <main class="view run"> was picking up the styling of .run, the "Run these one at a time" button. Caught in a screenshot, not by a test.
• The shelves are four because they are how you arrive. Making things, work, people, yourself. You do not come here browsing a taxonomy — you come with a specific bad afternoon.

What it is

The one-to-one version of Closest: no game, no scoring, just a deck. Say who is with you, draw a card, swipe for the next. It is installable and works with no signal, which is the only way a thing like this survives an actual dinner.

The ramp is the whole idea. The first four cards are light. Then the real ones come into play. After ten, the deep ones do — and the whole screen changes colour with the depth, cream to sage to night, so a conversation getting more serious is something you can see rather than something anybody has to announce. It is the only progress bar the app has.

242 of Closest's cards carried over, keeping only the ones that work without a table of people. Someone at work gets no deep pile at all — 81 light and 57 real cards exist for that column and zero deep ones, so the app greys the tile out and says none for this rather than putting something regrettable on the screen.

242 cards · 3 depths · installable · nothing recorded

Notes from the build

• A transform that zooms the phone out. The card is dealt by sliding it to translateX(115%). That widened the document, and a mobile browser answers a wider document by zooming the layout out — innerWidth went from 390 to 809 mid-deal. The stage clips now, and the walkthrough samples scrollWidth every 30 ms during a deal so it cannot come back.
• The ramp only counts if you can see it. The first version picked at random from the newly widened pool, so the card at the moment it was meant to deepen was often still a light one and the colour never changed. The card that crosses a boundary is now forced to come from the deeper pile.
• "Getting real" twice is worse than never. The announcement re-fired every time a shallower card came round again. Each depth is now announced once, remembered across reloads, and the shallow mix dropped from 35% to 15% so the field stops flickering.
• Three products, one bank. Closest, Tell Me and Questions For. all came out of idea #219 in a single sitting, and they are three different things: a game for a table, a deck for two people, and a reference for one person with a problem.

What it is

The note is not a feature list, it is a coordinate system, so that is what got built. Twelve axes — warmth, light, contrast, colourfulness, hue range, woodness, brassness, greenery, coziness, stuff, cleanness, weight — and a room drawn live from them in one-point perspective. Nothing is a photograph and nothing is a preset.

Two more inputs are deliberately not axes, because they are constraints rather than taste: how big the room is and what it is for. Size is what decides how much of the frame the back wall fills, so a small room reads as small — the two pictures above are the same coordinates and the same furniture at 7.8 m² and 34 m².

Five of the rulesets are not sliders. 60:30:10, negative space, palette consistency, value contrast and practicality are measured off the room after it is drawn — the colour rules from every fill in the SVG weighted by its area, the rest from the floor plan in centimetres. A rule you can dial to 100 tells you nothing. These are allowed to disagree with you.

12 axes · 4 purposes · 15 styles · 5 measured rules · no server

Notes from the build

• "Practical" is not one thing. A living room is wrong if you cannot reach a table from the sofa; a bedroom is wrong if somebody has to climb over somebody to get out; a study is wrong if the window is straight in front of the screen. So each purpose brings its own checks — 60 cm on both sides of a double bed, 90 cm behind a desk chair to stand up, 90 cm to pull a dining chair out and walk behind it — and the reading names the distance that is wrong.
• Half the failures were the planner's fault, not the room's. The armchair failed its own "something within reach" check in every room, because a sofa centred on the wall with a chair bolted to one end leaves nowhere between them for a table. The desk landed in front of the window and then complained about glare. Both are fixed where they belong — in the layout, not in the check.
• A measure that moves the wrong way is worse than none. Value contrast was read off colour families, and which family a surface lands in flips as its lightness crosses a bucket edge — so turning contrast down could push the number up. It is now area-weighted straight off the shapes: the darkest quarter of the picture against the lightest.
• Styles are coordinates, not categories. Which means the app can say you are 71% of the way to Japandi, and it can put you halfway between Brutalist and Cottage — a real room you can look at. A list of styles has no halfway.
• Warmth is not a rotation of the colour wheel. Interpolating blue to red the short way runs through green at the midpoint, so every "warm" room came out olive. It is anchored now through the range interiors actually use: cold blue, blue-grey, sage, oat, tan, terracotta.

Same numbers, different rooms

What it is

The note asks for models. None of it needs one — paddings, margins, sizes, colours, areas are all things you can measure, and the reason nobody measures them is that the screenshot has thrown away the DOM, not that the problem is hard. So: drop in a screenshot, and Squint takes it apart in about a fifth of a second, in the browser, with the image never leaving the tab.

Nine layers drawn over the picture — blocks, spacing, padding, alignment, type, contrast, colour, and a squint test that blurs the screen until only the hierarchy is left. Every number is in the CSS pixels of the original interface, which is the number in somebody's stylesheet, not the number in the file. A phone screenshot is three device pixels to one, so getting that wrong makes an 8 px grid look like a 24 px one.

Two fixture pages, not one. One has mistakes planted in it — an off-grid gap, a 3 px misalignment, two card colours ΔE 1.6 apart, a footer at 2.19:1 — and the walkthrough asserts each one is found. The other is built strictly on eights and has nothing wrong with it at all. Half the work went into the second, because it is very easy to build something that finds faults everywhere.

9 layers · 46 assertions · 0 dependencies · 0 bytes uploaded

Notes from the build

• The most common colour is not the background. Cover more than half a screen in cards and the cards become "the page", white becomes content, and every reading after that is inside out — margins of zero, no gaps between anything. The page is whatever the frame is resting on, so it is taken from the border ring instead.
• Ink-to-ink is not a gap. The same 12 px margin measures 16, 17 or 18 depending on whether the heading above it happens to contain a descender. Line boxes have to be rebuilt: baseline from where the x-height band ends, leading from the tightest baseline-to-baseline step, box from the em box centred in it. Without that pass a design built strictly on eights measures as noise.
• A tolerance that cannot fail is not a measurement. Gaps come out good to about two pixels, and at ±2 a 3 px grid matches nearly every integer there is — so it would always "fit". The headline is not the unit at all now. It is whether the numbers repeat: four values across ten gaps is a scale, ten values across ten gaps is ten separate decisions.
• Ragged text has no right edge. Measuring padding-right from the longest line is how you end up telling somebody their card is padded 229 px on one side. Only something that is not a line of type can certify that side; without one the honest answer is that it cannot be measured, and that is what it says.
• Lossy screenshots invent colours. A ΔE of 1.3 between two darks in a WebP is the encoder's opinion, not the designer's. Squint counts how many colours hold real area; past a few hundred it says the file has been compressed and downgrades those findings rather than blaming the person who made the screen.

The control, and the patient

What it is

Twenty pages that already look like something, so that no tool or project here has to begin on a blank one. Editorial, dashboard, brutalist, glass, terminal, magazine grid, card stack, landing hero, settings form, data table in the first batch; pricing, onboarding, chat, kanban, calendar, map + list, media player, docs sidebar, inbox, checkout in the second — one design language each, one file each, and a gallery to pick from.

Every shell keeps the same rules: colour, type, radius and gutter as tokens on :root with a dark set under prefers-color-scheme; no scripts and no build, Google Fonts as the only external request; 16 px gutters and no horizontal scroll at phone width; and no lorem ipsum — each one has a fake shop, a fake CLI or a fake magazine in it, because a layout full of placeholder Latin does not tell you what the real thing will look like.

The comment header at the top of each file lists its tokens and what it is for. Copy the file, keep the tokens, replace the words.

20 shells · 0 scripts · 3 viewports checked · 63 screenshots, 0 issues

Notes from the build

• The layout changes shape, it does not shrink. On a phone the dashboard's sidebar becomes a top strip, the data table becomes a list of cards with data-l labels, the editorial margin notes fold under the text, the settings rail turns into a row of chips. A design scaled down to 390 px is not a phone design.
• Charts and rings without a library. The dashboard's bar chart is divs with percentage heights, the glass shell's budget ring is a conic-gradient with a frosted disc on top, the sparklines are eight flex children. A shell that needs a script to look like itself is not empty.
• One token, two colours. Status pills take their ink from --ok / --warn / --bad and their tint from color-mix() of the same token, so the dark set only has to redefine three values and both stay in step.
• networkidle is the wrong gate for Google Fonts. The fonts CDN keeps a connection open long enough to time out a navigation now and then, so the walk flaked until it waited for load and then document.fonts.ready with a cap.
• A console 404 has no URL in its text. The analytics beacon is a 404 on the local server; filtering the message by location().url rather than its text is what let the zero-issue gate stay strict everywhere else.
• innerWidth is not the viewport on an emulated phone. With isMobile on, a page that overflows makes window.innerWidth grow to match, so the second batch's gate passed two shells that were 454 and 611 px wide at 390 until it compared against the width it had asked for. The cause both times was a 1fr column, which is minmax(auto, 1fr) and grows to the longest code line.

On a phone, and by night

What it is

A speed-reading trainer built on the one idea in the note that holds up: read in chunks of two to four words, not one. Read flashes one chunk at a time in one place, the fixation letter marked so the eyes have somewhere to land. Pace keeps the whole text on the page and sweeps a highlight through it at the same clock. Train is a ten-step course: sweep and span drills for the eyes, then pace reads in twos, threes and fours, then flash reads at 350, 450 and 550 wpm — each read followed by four questions, pass on three. Texts holds seven bundled pieces written for it, and anything you paste, open or drop in.

The clock is sentence-aware: a chunk never runs past a full stop, a comma is worth four tenths of a word, a paragraph break most of one. A reload lands on the same word. Nothing is uploaded, nothing needs a signal, and the course stops at 550 wpm on purpose, because past that the questions stop being answered.

7 texts · 28 questions · 10 course steps · 116 walkthrough assertions on a desk and an iPhone 13, 0 failures

Notes from the build

• A chunk closes at the full stop. “the lens. In” is not something anyone takes in at a glance, so chunks of three average about 2.6 words, and the time estimate has to be summed from the chunks rather than divided from the word count.
• Time is kept in word-times. A word is 1, a sentence end adds 1, a comma 0.4, a long word 0.35; a chunk's screen time is its weight × 60000 / wpm. The header's prediction and the walkthrough's wall clock agree within a few hundred milliseconds.
• The fixation letter is placed, not centred. Centring the string puts its middle under the reticle; the eye wants the middle letter. The flash is translated after each render — and a 16 px padding on it was silently wrong by exactly 16 px until an assertion said so.
• play() at the end must not restart. The first version did, for the Again button, and “seek to the last chunk and play” started over — so the course could never finish. Only a finished read restarts.
• Two things called .bar. The header and the progress track shared a class name; the header's flex rule collapsed the fill to zero height. Both screenshots showed an empty bar and the eye read it as “not started yet”. A rect assertion now guards it.
• Space, after a tap, did nothing. The stage listened for space and so did the page, so with the focus on the stage — that is, after every tap or click on it — one press toggled twice. The first walkthrough always pressed space with the focus on nothing. And :focus-visible cannot tell a clicked button from a tabbed-to one inside a keydown handler: the browser switches it on for the key being pressed.
• Drills say what they expect. CR.drill.expect is what the sweep flashed, so the walkthrough passes a drill the way a person would, fails one round on purpose, and checks that the miss is counted.

On an iPhone 13

What it is

A table to move your options around on. The note ends in a worked example written as I could… I will… I would not…, so those are the three lanes, and every option is a tile in one of them. Modules are the rows: a basecamp, the main work, bets, the rest of life. The one idea is that reversible and irreversible choices must not move the same way. A light tile is paper: drag it and it lands. A heavy tile is a dark slab: drop it on I will and a sheet shows what it does to the month, the hours and the money up front, how many futures it closes, and waits for a reason. Taking it back asks what changed? Both go in the log.

Each tile can carry money a month as a range, money once, and hours a week. A bar adds up the plan. Every pick-one module that is not closed by a decision is a fork, and Futures multiplies them out — five basecamps × three kinds of work is fifteen — and marks each leaf works, tight or breaks against the hours and the savings on the board, with the month the money runs out. Loose tiles are what-ifs: switch on the dog and its ten hours a week break every full-time future. A board travels as a link with the whole thing in its fragment, or as a file. Nothing is uploaded, and every number in the example is invented.

3 lanes · 3 verdicts · 7 library modules · 161 walkthrough assertions on a desk and an iPhone 13, 0 failures

Notes from the build

• A light pick keeps its fork. The first tree treated any seated tile as settled. But the note's whole point is that low commitment “can always be swapped out”, so a light tile in the seat still branches, marked now, and only a heavy one prunes. Deciding Lisbon takes fifteen futures to three; seating the house-sit takes fifteen to fifteen.
• A finger needs a rule a mouse does not. A mouse drags after five pixels. A finger that moves is scrolling, so a tile lifts only after a quarter of a second of rest, and from then on the page is held still. The walkthrough sends real touch sequences: a swipe that starts on a tile must scroll and lift nothing, a held one must lift and not scroll.
• The toast was a drop target. It floats exactly where a phone's lower lanes are, so the second of two finger-drags in a row was dropped on “Contract moved to I will… Undo” and went nowhere. Only a test that drags twice could see it.
• Class names are a namespace too. Four bugs were one bug: .in was the toast's entrance and the small-caps label, so toasts shouted; the tile sheet got the class tile and sat fourteen pixels above the bottom of a phone; .blank made the library's empty module unclickable; .works turned the plan bar green.
• A link is input from a stranger. The board rides in the URL fragment, so everything in it is cleaned on the way in and escaped on the way out. The walkthrough opens a board made of <img onerror> and checks that nothing runs.
• The deploy script sent files in batches, and this host truncates batches. That left empty files live for a week in September. It now sends one file per connection and only the ones that differ from what is being served.

On an iPhone 13

What it is

A small 3D platformer in which everything is fruit. The islands are halves of orange and lemon floating cut side up in a sea of juice. The bridges are bananas, the towers are pineapples, the springs are grapes, and the last level is one and a half turns round a strawberry the size of a house. You are Pip, a pip: walk, jump, jump again in mid-air. On every island a hundred and some little fruits turn on their own axis, the way the note asks, with three star fruit hidden off the path and sprouts to come back to after a dip in the juice. The result is a fruit salad: what you picked, by kind, your time, and the time the demo does it in.

There is not one image, 3D model or sound file in it. Every mesh is built from numbers when the page loads, every surface is painted by arithmetic in a shader — the segments of an orange are an angle modulo, a kiwi's seeds are a ring of cells — and every sound is an oscillator. It plays on a keyboard, a phone or a gamepad, and offline once it has loaded. What it has not had is a person: it was built and proven by bots in one night, and nobody has yet felt the jump.

4 islands · 601 fruit · 12 star fruit · 132 walkthrough assertions on a desk and an iPhone 13, 0 failures

Notes from the build

• The fruit hangs where the jump goes. The first trails were sine curves from one platform to the next, and a bot following the same route missed fifteen fruit in a hundred and ten: a held jump sails over fruit laid after a short gap, a double jump is an M and not an arch. So the levels stopped saying where the fruit is. A bot that can press a direction and jump, nothing else, walks each island once, and a fruit is hung on its path every stride and a half. The trail is the jump, and “every fruit can be reached” is something the build proves.
• Two copies of the same engine disagree about a cosine. Node and the test browser, both V8, differ in the sixteenth digit of Math.cos. That was enough for the page to decide all four islands had changed since they were baked. The walk is done once and shipped as data; fingerprints are rounded before they are hashed.
• Perfect hands prove a level possible, not fair. The same bot run 50 ms late, steering a little off and dropping one press in twenty first showed a bug in itself — with any lag it pressed jump twice and wasted the second jump — and then three jumps that were simply too hard. Those gaps went from 5.2 to 4.4, the apple slices from 1.25 across to 1.5.
• “Sound on” could only switch it off. Object.assign reads a getter once and copies the answer, so audio.sound was true for ever and the label never changed. Nothing looked wrong; the assertion that the button says Sound off found it.
• The clock is stopped for the test. The page loads frozen and the walkthrough turns the handle one sixtieth of a second at a time, through the real loop, with real key and touch events. A held jump is 43 steps, every time. And the software renderer this machine has, good for about two frames a second, is asked for a few dozen frames instead of ten minutes of them.
• A second jump on the way up off a grape replaced the throw. 17.5 became 10.2 and Pip fell short of the very platform the grape was there to reach. The second jump now adds to whatever is already carrying you up.
• The prize hid the hero. A giant orange turning at head height over the finish sat exactly between the camera and Pip. It hangs higher now.

On an iPhone 13