Both versions of Consecutive — an homage to the board game Sequence, with an original board and name — were written entirely by LLMs. Only the harness differs, same as the RowClear entry. The hare got one prompt and ships frozen. The tortoise got the same methodology as last time — vend (intent → reviewed backlog) and lisa (backlog → shipped code) — and something new: home-court advantage. This entry's definition of done is not "a stranger can play it." It is "we play this on weekends" — the two household members who asked for the game keep coming back to it. That single sentence moves the finish line somewhere only one contestant can reach.
The Prompt Had to Grow
RowClear took six words. It is the most famous program shape there is; the model has seen ten thousand of them. Sequence is a board game, not a program shape — so the hare's prompt had to carry what training data doesn't: twenty-two words naming the genre, the homage, the artifact shape, and the need for an opponent. That growth is data. One-shot prompting is cheap exactly where the territory is already mapped; the price rises the moment you step off the map. And to be clear about how far twenty-two words went: the non-obvious rules are present — one-eyed jack removals, a dead-card badge on unplayable cards, wild corners, locked-sequence markers. What play revealed about their correctness is the next section's story.
Day One Standings
Honesty first: the hare's lap is remarkable. One prompt to Fable 5 at extra-high reasoning effort came back with 765 lines that play a complete, handsome Consecutive — felt table, fanned card hand, chip shading, dead-card badges, one-eyed jack removals, wild corners, gold-starred locked sequences, a last-move marker, and a computer opponent that puts up a real fight. The household verdict after the first sessions: a highly playable rendition that would have flabbergasted a 2010 forum user, and better than most of what a casual search for an online Sequence game turns up today. Read that plainly. The single shot didn't just clear the bar — it may have produced the most polished implementation of this game in existence. Twenty-two words. That is the day-one standard the tortoise has to answer, and it's a higher one than RowClear set.
The tortoise, for the record, spent that same stretch building a compiling walking skeleton: eight tickets, three packages, sixty test-runs across two compile targets, and a board that renders from a folded game record — but not yet a game you can play. Day one goes to the hare, as the series expects. This one goes to the hare by a lot.
Then the players kept playing.
First came the wishes — the ordinary, reasonable kind any game earns in its first ten minutes: "I can't see which card a cell is once a chip covers it." Then came the bug: the computer declared victory on a line of four. The implementation that had looked immaculate got the game's single victory condition wrong.
Neither dents the day-one achievement. Both pose the question this series exists to ask: where does this feedback go? The hare has no intake. Its 765 lines are frozen — by series protocol, yes, but really by their nature: zero tests to guard a fix, no seams to receive one, and re-prompting means gambling the whole file on every edit, ten times for ten notes. The tortoise's board accepts both notes as ordinary tickets. And its sequence detection is slated to be property-tested against precisely the class of defect the hare just shipped — a win condition is the kind of invariant you prove, not eyeball. Day one was days ago. The feedback has already outlived it.
A Different Blueprint: Lichess, Scaled to Two
The RowClear tortoise was an app. This one is modeled on Lichess — the chess server that carries chess.com-scale traffic with roughly one and a half maintainers — because its load-bearing decisions all get stronger at household scale:
A game is a record, not a session. Every game is a seed plus an ordered move list; board state is always derived by folding a pure rules engine over the events. Reconnect stops being a feature — there is no session to lose, only a record to re-read. Live play and move-when-you-walk-past-the-iPad async play become the same system with different push channels. Replay and post-game review come free.
A notation contract. Games serialize to SGN — a PGN-style, human-readable record. The engine's whole interface is notation in, legal moves out. Bug reports are game files. Property tests run over round-trips. The shell around the contract is swappable.
The AI is a peripheral, not an organ. Like Stockfish behind UCI, the opponent is a stateless function from game record to move. Difficulty levels, hints, and blunder review are callers of the engine, not features woven into the app.
Frugality by deletion. Two real players delete the auth system (two standing identities), matchmaking, anti-cheat, moderation, and the scaling tier. What stays is the rivalry ledger — lifetime head-to-head, streaks, a two-person Elo played for laughs — because for an audience of two, the ledger is the reason the app gets opened next weekend.
None of this is exotic engineering. It is a stack of decisions about what not to maintain — and it is precisely the kind of structure that has no single-HTML-file shape.
We Also Didn't Know the Language
The tortoise is written in Gleam — a small, statically typed functional language — with Lustre on the client. Nobody on the team knew it. The team is a compiler and a pipeline.
The bet: Gleam compiles the same module to the Erlang VM and to JavaScript, so the rule "the server validates with the exact engine the client predicts with" is a language feature instead of a build trick. Exhaustive pattern matching makes illegal game states compile errors. And a tiny language with a strict compiler is a gift to a review-automated pipeline — every hallucinated API dies at the first gate instead of shipping.
The first loop is in, and the bet paid. Eight tickets, zero blockers, and no invented API survived to a commit — the ones the model reached for from memory died at gleam check (it assumed list.range exists; in the pinned stdlib it doesn't). What mattered wasn't the model knowing Gleam — it was the harness forcing it to find out: before designing against Lustre, an agent resolved a throwaway package and read the resolved source, confirming among other things that Lustre's browser-mount calls have safe server-side fallbacks, so the same client module stays test-green under the Erlang pass. The type system went further than catching errors — it twice rejected tests as redundant, because the compiler had already statically proven what the test asserted, and pushed the suite toward exhaustive pattern matches instead. Across the whole loop, human-style code review caught zero language mistakes: the compiler got every one first, which is exactly the division of labor we hired it for. The two-target promise held from the first commit — every engine and view module runs its tests on both the Erlang VM and JavaScript. One honest caveat: this loop's UI is a static render; the full Elm-architecture test arrives with interactivity.
The hare kept its best lane: one HTML file in JavaScript, the richest training distribution there is. The asymmetry is part of the exhibit. The tortoise chose the right tool; the hare is structurally confined to the familiar one.
Speed Becomes the Liability
Here is the entry's thesis. The hare's great virtue — a complete artifact in minutes — inverts under a weekend-play definition of done. A frozen file cannot absorb Saturday's feedback by Sunday. It caps at hotseat multiplayer, because a static HTML artifact on a static site has nowhere to keep a shared game. It has no record, so there is nothing to resume, nothing to replay, nothing to keep score across weeks. The hare can one-shot a game. It cannot one-shot a place where games accumulate — and the accumulation is what a two-person audience actually returns to.
[PLACEHOLDER: the infrastructure ledger. Entry 1 paid for its deploy the hard way — a six-ticket migration epic and a runbook of CSP transform-rule surgery. This entry pre-paid: wildcard embed rules on the zone, a pinned flox toolchain, CI/CD from the first commit, a scale-to-zero Fly machine that costs nothing while the court is empty. Report the deploy attention in human minutes, entry 1 vs. entry 2.]
Scoring
[PLACEHOLDER: the scorecard, once both contestants are frozen/live. Candidate axes: rule fidelity (the jacks, dead cards, shared-chip sequences), day-one playability, features at week two, tests (the hare will have zero; report the tortoise's property suite — layout invariants, notation round-trips, AI-vs-AI determinism), and the series' real metric — human attention per change, extended this time to human attention per week of staying alive. The showcase pane above is itself evidence: it is the production rules engine, compiled to JavaScript, folding a real recorded game in your browser. The hare's pane is a file. The tortoise's pane is a system quoting itself.]
Retrospective
[PLACEHOLDER: written after the household has actually spent weekends with it. Did the game get opened without ceremony? What did play sessions surface, and what did each wish cost to land? The RowClear entry closed with "every day after goes to the contestant with an intake" — this entry exists to test whether that holds when the intake has to survive contact with two real, opinionated players and a sleeping server. Report the standings honestly, including anywhere the tortoise stumbled: cold-start friction, Gleam ecosystem gaps, pipeline overhead on a project this small.]