Rover Island

Under the hood — for the technical folks

I built Rover Island in Claude Code, in a repo of its own. I designed it, picked how it looks, moves and sounds from playable sketches, and tested it; Claude Code agents built much of it, several islets at once.

It’s plain three.js and TypeScript on Vite, with no game engine. There are no texture, model, image or audio files: every prop and character is built from simple shapes in code, low-poly and flat-shaded, and the sound and music are synthesised live with Web Audio.

The archipelago is a set of levels, not one big map. Only the islet the rover is on and the crossing it’s driving exist in the scene; every other island is a cheap silhouette on its true compass bearing. A crossing’s camera is keyed to how far along the route you are, not to time, so driving forward scrubs through a shot list of moving shots and letterboxed long-lens cuts. Partway across, a trick in that islet’s own camera language covers the swap: the old level is disposed and the new one goes in whole.

The next level is built ahead while the rover crosses, one prop at a time, with its shaders compiled in the background. Before that change, the first trip over a crossing could freeze for up to about a second; after it, no frame on any crossing’s first trip went over 50 ms on a desktop graphics card. Each islet lives in its own folder and downloads only when you head for it, so pressing Play stays inside a 300 kB budget (gzipped) that a size check guards, and every view measured stays under a budget of 300 draw calls.

My words live in the page, not in the game. The case studies stay in the site’s HTML; the game finds them there and the keepers quote them. Quest progress belongs to the page. The game keeps only its own save (errands, the rover’s kit, where you were), and blocked storage means nothing gets saved, never a broken game.

Technical highlights:

• Vitest unit tests for the pure parts, plus audits of routes, prop overlaps, camera framing and colour that fail the run when something drifts
• A headless Playwright smoke run that drives every crossing both ways and counts the pixels each swap changes, so a level popping into view fails the check
• A copy test that keeps the game’s own lines clear of words the site’s voice rules ban
• Each level’s look (sky, palette, fog, light, weather, water) in a style file, tuned live in a panel that only exists in development
• A Dev panel, also development-only, listing each decision waiting on me: “Show me” drives there, rings the thing in question and flips between the options in place, and my picks save to a file Claude Code reads
• Reduced motion turns camera moves into cuts, swaps into a plain fade and text into instant text
• Released by tag: the site scans a tagged release with its banned-patterns check before copying it in, then runs its own Playwright suite over the page around the game

---

What I wanted

The site already had two ways in, the graphical pages and the terminal. I wanted a third that felt like a video game, without putting a 3D download in front of someone who only wants to read.

So it had rules from the start. It’s opt-in, behind a Play button. Every case study stays readable without playing, and contact is never locked behind the game. And it adds nothing the site doesn’t already say: the same work, in a different place.

How I got it

The first version wasn’t a game. I started in October with a careful plan, and the first thing built was the page around the game: an illustrated map, a quest log and reading panels, all tested, with no 3D in it yet. When I opened it, my reaction was simple: this isn’t a game. So the order flipped. A rough playable prototype came first, a rover driving round one small island, and the engineering came after I’d driven it.

From then on I chose by playing. Camera styles, the crossings between islets and the tricks that hide each swap all came to me as small playable sketches, side by side and labelled, and I picked from those rather than from descriptions. Later decisions happened inside the game itself, in the Dev panel.

The game moved into a repo of its own, and this site takes a tagged release of it. Timber Isle came first. It was built alongside the engine and is the islet taken all the way to finished: the bridge that builds itself ahead of the rover, the island inking itself in from a blueprint, the beaver who keeps it, an errand. It became the template. Then Claude Code agents built the other six in parallel, one agent per islet, each working only in its own folder against the shared engine.

One rule I set for the words: the keepers never state facts about me. Everything the game says in its own voice is flavour, like greetings, banter and errand chatter, and I read every new line before a release. When a keeper talks about a project, it reads my case-study notes back, word for word, straight from the page. The game never paraphrases me, so it can’t put words in my mouth.

What it does

Press Play and you’re a small rover on a hub island at night, with a lighthouse on the hill and seven departure points round the coast, one per project. Drive onto one and hold forward: the rover follows its own route across the water while the camera cuts between shots, and partway over, something covers the change to the next islet: a power cut, a tall ship sailing past, ink spreading out from a blueprint.

Each islet is its own place, with its own sky, colours, music and keeper. On Timber Isle the bridge builds itself plank by plank just ahead of you, and a beaver at the blueprint table reads you the House Editor case study a couple of sentences at a time. Talking to a keeper lights that islet’s lantern. Light all seven and the lighthouse switches on, with a way to reach me.

There’s more if you want it, and none of it is required: errands that earn kit for the rover, a garage on the dock to change it, a map, and fast travel to anywhere you’ve already been. Every case study, and contact, stays one click away the whole time.

The island holds seven of the projects on this site; this one and the terminal aren’t on it. It’s built for a desktop browser, and on a phone, /island leads with an illustrated map and the same case studies.

Why it matters to me

It’s the largest thing I’ve directed so far: a whole game, built by several Claude Code agents at once, with me deciding how it looks, moves and sounds. What made it hold together wasn’t the 3D. It was the agreements underneath: a folder per islet so parallel work never collided, one engine every islet built against, and a contract with the page that keeps my words in the site and keeps the game out of the facts business.

It also keeps the same discipline as the rest of the site in a place where it would be easy to drop. The plain site stays the default, nothing about me is invented for a character to say, and no release reaches the site until it passes the same checks as everything else.

What I learned

Order mattered more than effort. The first version had plenty of effort in it and was the wrong thing, because nobody had played anything yet.

The same lesson came back at a smaller scale. Four of the crossings were built before the shared crossing engine landed, and all four had to be rebuilt the next day. After that the rule was platform before content: land the shared engine first, then send agents out to build on it. Building one islet first, as the template, is what let six get built at once without six different ideas of what an islet is.