Hypercolor Asteroids

Two pilots, one keyboard. Rocks split, a kraken dives and surfaces underneath you, a grapple swings you rather than reels you in, and a smuggler turns up with one enormous laser. The field guide on the splash screen is generated from whatever registered itself, so it cannot go out of date.

Opening index.html is the whole install: no dependencies, no build step, nothing fetched. That is a checked promise rather than a hoped-for one, which is the first place the second game shows through this one.

Somebody lands a version tonight. You pull on Thursday, press Enter, and find out what changed by playing it: no changelog, no announcement. The diff is not the deliverable; the surprise is.

36 versions have arrived that way, and the README still describes the cabinet rather than the changes, because a release note would spend the only thing the format has. Nobody assigns the version numbers either; they are read off the history.

versions landed

36

changelogs

0

pilots

2

The second game needed a referee that never sleeps, so the rulebook is executable: 16 golden rules on one page, eight of them unbendable, each backed by one of 20 small tools written in sh. A rule without a tool behind it is an opinion; these run in the hooks and in CI, against every commit.

Bending a bendable rule is always allowed and never quiet: one line in the commit message and you are through, on the record, in a history that remembers who wrote it. What that costs comes two sections down.

The repository also keeps its own chronicle (a page that writes itself a chapter per version) and a board of flight records nobody can type their way onto. The next three sections are the three rules the whole game hangs on, each carrying its number in the rulebook.

Somebody wrote that ambush, and it fires for everyone except them. No override exists, because the mechanic rests on nobody being able to disarm the one that is waiting for them: every pilot who lands a trap is also flying into every trap the others landed, and from inside the game there is no way to know which is which until the field starts closing.

It is the git game's best trade. The thing you contribute is a thing you specifically will never see, so the only reason to write one is to do something to the other seat, which is what a two-player game played through a repository actually is.

The why lives in the history. Every rule-bend is counted off the git log into a ledger the game reads at play time; nothing is blocked, your field simply gets harder. The difficulty you fly against was set away from the cabinet, by what you did to the rulebook, and the only place it is written down is a file you are not looking at while you play.

1. 0 bends

   An empty ledger. Nothing at all; the field behaves.

2. 1 or more

   Ambushes come for you sooner: the interval scales down, to a floor of half the usual gap.

3. 3 or more

   Author immunity is revoked: traps you wrote yourself start firing at you.

4. 4 or more

   A wave turns up carrying one more ambush than it should.

Three clean landings ease it back off. Going round the referee instead of through it costs two rather than one, and that is not a loophole left open: the ledger is recomputed from the history rather than trusted, so any commit whose ledger disagrees with the history is refused. It is the one number in the project nobody writes for themselves.

A referee reads code; it never presses Enter. So the promise that the game still plays is checked by quota instead: a sealed flight buys three landings, and landing a fourth version without having flown one means writing down why.

Nobody writes a tape by hand: a red line pointed straight at the assistant sitting at this keyboard, because an agent is exactly what you would ask to manufacture the evidence. The seal is honesty rather than security and the repository says so: eight hex digits are eight hex digits. What it costs is inventing a number that must not already be on a public board, in a history that remembers who wrote every line of it.

Most turns on this cabinet are taken through Claude Code, and this is what one looks like when a version lands: the pilot types a sentence, and the assistant walks the whole ritual: looks around, reads the rulebook, builds the comet in its own file, faces the referee, and flies the build before calling the work done, because GR1 is a promise to somebody who is not in the room.

Comets, and one a wave is plenty

Chronicle: Dave wanted something worth
           chasing. A comet crosses once a
           wave now, pays double, and does
           not slow down to be caught.

      .        *          .
          __/\__       *
   * ---=[ o  o ]=---     .
           \  /        .
      .     \/     *

The replay is illustrative, but nothing in it is invented: every tool is a real file in the repository, the referee’s verdict is quoted from it, and the comet is the worked example the project’s own instructions use. The Chronicle: line in the commit message is the sentence the book prints; the hooks count the version and write the chapter on their own. What is left for a person is the merge button, and the next pilot still finds out what landed by pressing Enter.

commits in five days

278

files in src/

68

referee tools, in sh

20

rules, 8 unbendable

16

Claude Code skills

8

Counted off the repository on 10 August 2026, five days after the first commit.

Five days old, 2 pilots. The social half is designed for a room and has so far been tested by a room of two, so whether the difficulty loop reads as funny or as nagging at ten pilots is unproven. Most turns here are taken through Claude Code, and the repository says so: the checks live in the hooks, in a per-commit CI verdict and in a person pressing merge, none of which asks who typed the diff.

Two seats, one keyboard, nothing to install. The game is the shortest way into the repository, and the repository is the whole thing.