No. 03 · Comparison · Browser game
Same brief, different models
Six AI models build the same browser game
I gave five AI models one detailed brief for a browser game I'd already built with a sixth: each in the tool I'd use it in, one go, no feedback. Play all six versions and see what the differences tell you about the models.
My ranking
Pick a game for my verdict, or press Play to try it.
-
#1 Claude Opus 5.5 Claude Code My score: 5 out of 5 : see my verdict Play -
#2 Grok 4.7 Grok Bot · the original My score: 3.5 out of 5 : see my verdict Play -
#3 GPT-6.1 Sol Codex My score: 3.5 out of 5 : see my verdict Play -
#4 GPT-6 Astra Codex My score: 3 out of 5 : see my verdict Play -
#5 Gemini 3.8 Flash Antigravity My score: 2 out of 5 : see my verdict Play -
#6 GLM-5.3-Flash OpenClaw via OpenRouter My score: 1.5 out of 5 : see my verdict Play
Why compare models at all
Every model has its own strengths and weaknesses, and so does every tool you run it in. A leaderboard tells you which model won someone else’s test. It doesn’t tell you how a model handles the kind of work you’d give it: what it gets right without being asked, where it cuts corners, and what it does with the parts nobody wrote down.
The tool matters too. In Claude Code and OpenClaw, the models played their own games in a browser before handing them over, and OpenClaw kept GLM working on its version for several hours. So what you’re really comparing is a model and its tool together, the way you’d use them.
Give several of them the same piece of work, put what comes back side by side, and you get a much better feel for each of them.
Why a game
A game is a demanding piece of software. It needs good design on three levels at once: the mechanics, the look and the sound. This one also needs physics that feel right, with gravity, water and momentum. And it has to be tested through every stage of a run. When I built the original, the camera lost the dolphin on the way down from above 300 km, and nobody would have found that without playing that far.
A game is also easy to judge, and you don’t have to read a line of code to do it. Within a minute of playing you know whether it feels good. Finding what’s broken takes longer.
What I did
I had already rebuilt one of my teenage favourites, the Flash game Dolphin Olympics, with my AI assistant on Grok Bot, over five rounds of playtesting. Here’s how that went.
Could other models get there in one go if they got everything the playtest rounds taught me up front? To find out, I wrote down the finished game’s rules, its jokes and the lessons from those rounds as one brief and gave it to five more models. Every model got the same brief and the same message, ran in the tool I’d use it in, and had one go, with no feedback from me.
I’m ranking the results, not claiming this was an entirely fair comparison. Each result is a model and its tool together, it’s one run each, and I’m the only judge. The original also had a different deal: five rounds of my feedback. Those rounds were mostly about game mechanics I hadn’t explained well enough, not about looks or sound, and the other models got a much better brief than Grok ever did. Still, it’s balanced enough to show the differences, and the brief is at the bottom of this page if you want to run it with your own tools.
How they did
Claude Opus 5.5 won by an order of magnitude, and it’s the only one that beat the original Grok built over those five rounds. The two OpenAI models landed in the middle, and OpenAI’s flagship, GPT-6 Astra, didn’t beat GPT-6.1 Sol. GLM-5.3-Flash, the budget model behind my OpenClaw assistant, worked for hours and came last, but the whole run cost USD 3.11.
All 6 versions, one by one
Each game opens on its own page, as the model delivered it. The run facts for all 6 are in one table further down.
-
My score 5 / 5
My verdict
Insanely well made: superior game design, graphics, proportions, sounds, easter eggs and gags. The clear winner, by an order of magnitude.
Worth knowing: Despite the instruction, it started by looking for existing files in its workspace. The workspace had nothing related, so there was nothing to find. My generous guess: it wanted to make sure it wasn't meant to continue work already started.
What Claude Opus 5.5 said about its own game
“I'm most proud of the climb: one continuous jump can go from the pool, past the ISS, planets and comets, to the neon Diner, with the camera zooming out instead of speeding up time, so the easter eggs stay readable. The balance is measured, not guessed: an autopilot played full five-minute games, and skilled play reaches the Diner in about 190–310 s while sloppier play stalls between the clouds and the outer planets. With more time I'd play it on real phones, because all testing ran in headless Chromium, so touch feel, the sound mix and performance on low-end devices are unchecked. I'd also tune the 20° clean and 6° perfect dive margins and the belly-flop plunge with human playtesters, since the bot reacts faster than any person. Finally, I'd add light background music and give the dolphin more reactions on the way up.”
-
My verdict
The graphics are somewhat simple but nicely made and creative, and the sound is OK. But the physics and the control of the dolphin feel great, with nice acceleration effects.
Worth knowing: Grok Bot doesn't show which model it used. I assume Grok 4.7, xAI's strongest model at the time.
-
My score 3.5 / 5
My verdict
Surprisingly ugly, with sounds that don't match.
Worth knowing: Ran at Ultra, one level below Max, which Codex also offers for this model. Same score as the Grok original; Grok ranks higher because it feels nicer to play, which is purely subjective.
What GPT-6.1 Sol said about its own game
“I’m most proud of the charged-dive progression, readable landings, and original artwork all the way to the Diner. With more time, I’d refine the difficulty through broader phone playtesting.”
-
My score 3 / 5
My verdict
Not really better than what GPT-6.1 Sol made.
Worth knowing: A late addition: OpenAI's flagship, run at Max. It got the same message as GPT-6.1 Sol, storage key included, so the two GPT versions share one leaderboard and sound setting in your browser.
What GPT-6 Astra said about its own game
“I’m proudest of the progression from clean dives to cosmic absurdity, with every visual and sound generated in code. With more time, I’d refine the difficulty through human playtesting.”
-
My score 2 / 5
My verdict
Hilariously buggy: the game world has edges, and the dolphin clips through them and teleports to the other side. It looks neat, though, the mechanics are fairly smooth, and the acceleration effect is well done.
What Gemini 3.8 Flash said about its own game
“I'm most proud of the acrobatic game feel and momentum curves—from buoyant underwater sweeps and hang time in microgravity to the tight, satisfying nose-first dives that launch you past planets and cosmic easter eggs all the way to the Diner at the End of the Galaxy. The entirely synthesized Web Audio soundscape also brings the run to life with live aerodynamic wind noise, pitch-escalating flip chimes, and rewarding dive chords with zero external assets. The dynamic camera feels natural and responsive, smoothly framing celestial milestones while panning down during rapid descents so players can always anticipate the approaching water. With more time, I would introduce interactive schools of fish and coral rings to swim through in the pool for underwater trick setups. I would also add a semi-transparent ghost dolphin showing your personal-best trajectory on your highest runs.”
-
My score 1.5 / 5
My verdict
Quite poor, but it did all that work for USD 3.11.
What GLM-5.3-Flash said about its own game
“What I'm most proud of: the run's escalation actually feels like the brief's fantasy — each clean dive visibly charges the next launch until the altimeter is spinning through billions of kilometres, and the final frames (Jupiter's bands looming past the dolphin, Uranus's sideways ring, the Earth's curved limb glowing below, then that neon DINER sign) land exactly the "enormous" note the brief asked for. I'm also quietly pleased that the floor is a genuine character in the game: clean entries brake hard while belly flops plunge you toward the sand, so the danger the brief demanded emerges from the physics instead of a scripted rule. With more time I'd tune the touch experience properly — the on-screen buttons work but thumb ergonomics, haptics-style feedback, and portrait-first camera framing deserve real device testing rather than my headless approximation. I'd also add a lightweight tutorial echo (the first dive teaching "dive deep, turn, sprint" with the floor-sign gag doing more work), and ghost-replay trails of your best run so the leaderboard taunts you visually.”
The runs in numbers
Effort is the reasoning setting, named the way each tool names it. Usage is the share of the subscription's limits a run took, as the tool reported it. The plans differ, so compare usage only loosely. Cost is shown where a run was paid per use. Size counts what the model wrote, without the site's link back to this page.
| Version | Tool | Effort | Usage or cost | Size | Built |
|---|---|---|---|---|---|
| #1 Claude Opus 5.5 | Claude Code | Max | Under 5% of the weekly limit on Claude Pro (the 5-hour share wasn't recorded) | 2,783 lines · 148 KB | 10 October 2026 |
| #2 Grok 4.7 | Grok Bot | Not recorded | About 10% of the weekly limit | 581 lines · 44 KB | Over five rounds |
| #3 GPT-6.1 Sol | Codex | Ultra | 35% of the 5-hour limit, 6% of the weekly limit on ChatGPT Pro | 710 lines · 73 KB | 10 October 2026 |
| #4 GPT-6 Astra | Codex | Max | 94% of the 5-hour limit on ChatGPT Pro | 299 lines · 56 KB | 10 October 2026 |
| #5 Gemini 3.8 Flash | Antigravity | High | 8% of the 5-hour limit, 1% of the weekly limit | 2,460 lines · 90 KB | 10 October 2026 |
| #6 GLM-5.3-Flash | OpenClaw via OpenRouter | Max (the default) | USD 3.11, paid per use through the OpenRouter API (no subscription); took several hours | 1,712 lines · 74 KB | 10 October 2026 |
Ground rules
- These rules apply to the five models that got the brief. The original is the game I built with Grok Bot over five playtest rounds.
- Every model got the same brief and the same message. Only the storage key differs, so the versions don't overwrite each other's high scores (GPT-6 Astra, a late addition, got GPT-6.1 Sol's message and key).
- One go, no feedback from me, and no web, no repositories, no local files. If a model could test its own work in a browser, it was allowed to. If a reply stopped mid-file, the only follow-up allowed was the word "continue"; questions got "Decide for yourself, as the brief says."
- Each model ran in the tool I'd use it in (Claude Code, Codex, Antigravity, OpenClaw), at the highest effort setting the tool offers (for Gemini in Antigravity, that's High), except GPT-6.1 Sol, which ran at Ultra, one level below Max. The tools differ in what they can do, for example whether they can test the game in a browser, and that's part of the result.
- Each game is published as delivered. The site only adds a link back to this page and a description for sharing; nothing in the game is changed.
- I played every version, ranked them and gave each an overall score from 1 to 5. One run each, one judge: it's a snapshot, not a verdict on the models.
The brief the five models got About 1,450 words: the rules, the jokes and the playtest lessons, written down once. Use it for your own run.
# Splash Olympics: the brief
Build **Splash Olympics**, a browser game in tribute to *Dolphin Olympics*, the Flash-era game where you dive deep, build up speed underwater, burst out of the pool and do flips in the air. It will be published on a website about AI, played by curious adults on a computer or a phone. Most of them will play for a few minutes. Make those minutes great.
The sections below describe a version that has already been played and refined over several rounds, plus a few technical requirements added so every version can be published the same way. Treat them all as requirements. Everything they don't decide is yours: art style, how the dolphin looks, the jokes, extra easter eggs, extra polish. Aim for the version you'd be proud to ship, with a beautiful first frame, a game that feels satisfying in your hands, and a sense of humour.
## The fantasy
You're a dolphin in a pool. You swim down, turn, and race up to the surface as fast as you can. You burst out of the water, spin through flips, and dive back in nose first, cleanly. Every clean dive makes your next jump more powerful, so a good run climbs from a few metres above the pool to the clouds, to space, past the planets, and finally to a diner at the end of the galaxy.
## Core loop and physics
- **Underwater:** holding "swim" pushes the dolphin forward in the direction it faces. Left and right rotate it. A dolphin doesn't drift sideways: its movement follows the direction it faces, with water drag and a slight upward buoyancy.
- **Launch:** leaving the water fast enough makes the dolphin airborne. Too slow, and it just bobs at the surface.
- **In the air:** gravity takes over. Left and right spin the dolphin quickly, so you can flip. Front flips and back flips are counted separately, relative to the direction of travel.
- **Re-entry:** what matters is the angle between where the dolphin points and where it's moving.
- A **clean dive** (nose roughly along the direction of travel) scores and charges your jump power.
- A **perfect dive** (very close to exact) scores more and charges jump power more.
- Anything else is a **belly flop**: it costs jump power, resets your combo and plunges you deep, so watch the floor.
- **Jump power:** a multiplier on launch speed. It grows with every clean dive (more for perfect ones) and shrinks on a belly flop. It's what turns a run from metres into space, so the progression must be felt.
- **The pool floor:** touching the sandy bottom with any real speed ends the game.
- **The clock:** five minutes for the whole game. When time runs out mid-jump, the game ends when you land.
## Scoring
Score each jump on height, air time and flips; more flips per jump should be worth disproportionately more. Then apply the entry:
- clean dive: the jump scores;
- perfect dive: ×1.5;
- front flips and back flips in the same jump: another ×1.5;
- belly flop: nothing.
A combo multiplier grows with each clean landing that included flips (cap it) and resets on a belly flop. Reaching altitude milestones pays a bonus, and flying through objects in the sky pays points (easter eggs pay more).
## The journey upward
The sky changes with altitude, from blue to deep blue to black, with stars appearing and the Earth's curve showing once you're high enough. In order, roughly:
1. Seagulls.
2. Hot-air balloons, in several clearly different designs.
3. Passenger planes at cruising altitude.
4. Weather balloons in the stratosphere.
5. The edge of space: satellites, then astronauts.
6. Leaving Earth's orbit (a big bonus), UFOs.
7. The Moon, Mars, Jupiter, Saturn, Uranus (it deserves a joke), Neptune, Pluto ("still a planet to us"), with comets in between.
8. At the very top: **the Diner at the End of the Galaxy**, with a neon sign and the line "So long, and thanks for all the fish".
Altitude shows on screen in metres and then kilometres. It doesn't need to be to scale; it needs to feel enormous.
## Easter eggs
These must be in the game, as things you can fly through for points:
- the Hubble Space Telescope;
- the ISS (wave at the crew);
- a falling whale and a bowl of petunias ("Oh no, not again");
- a towel that says "Don't panic";
- a red roadster with a spaceman at the wheel;
- Voyager and its golden record;
- Russell's teapot, in orbit;
- a bonus when the altimeter reads 42 (you pick the unit), for "the answer to everything".
Add your own if they're funny.
## Camera
These came out of playtesting:
- **Zoom out the faster you fly**, so you can see how high you are and the things you pass. Don't speed up time instead: the easter eggs must not blur past.
- **Always keep the dolphin in frame**, at any speed and height, including the long fall from the top.
- **When falling fast, keep the dolphin in the upper part of the screen**, so you can see the water coming.
## Balance
Also from playtesting:
- The fall back to Earth must not be too fast to enjoy.
- It must be possible to lose. Keep the margin for a clean dive tight enough that a careless dive is a belly flop, and make the pool floor a real danger.
- A skilled player can reach the Diner within the five minutes. A first game usually won't.
## Records and feedback
- A **local top-5 leaderboard**: score, highest altitude and date. Show it on the title and game-over screens.
- Live alerts during play: when you're close to your record (within 20%), when you enter the top 5, and when you beat your record.
- Pop-up text for flips, dive quality, combos, milestones and easter eggs.
- The game-over screen shows the reason (sand or time), the score, the highest altitude and your rank.
## Sound
Every sound is synthesized live with the Web Audio API; there are no audio files. At least: splashes (small and big), the launch, flips (front and back sound different and rise in pitch as they add up), clean and perfect dive chimes, the belly flop, the bonk on the pool floor, pickups, an easter-egg jingle, milestones, bonuses, a record fanfare, warning ticks in the last 10 seconds, game over, bubbles while swimming, and wind that rises with speed. Audio starts only after the player's first click, tap or key press. There's a mute toggle (the M key and an on-screen button), and the game remembers the choice.
## Controls
- **Keyboard:** Left/Right arrows or A/D to rotate. Up arrow, W or Space to swim. Enter or Space starts and restarts (a key still held down from play doesn't count, so the game-over screen stays up). P pauses, M mutes.
- **Touch:** on-screen buttons to rotate left, rotate right and swim, big enough for thumbs. Tap to start and restart.
- A click or tap also starts and restarts. Show the touch buttons on touch devices only; on a computer you play with the keyboard.
## Technical requirements
These are new for this comparison, so every version can be hosted the same way. They're fixed:
- **One self-contained HTML file.** All CSS and JavaScript inline. No libraries, no external requests of any kind, no web fonts, no image or audio files. Draw everything in code on a canvas (HTML elements for buttons are fine).
- **Smooth:** aim for 60 frames per second on an ordinary laptop and phone. Physics must not depend on the frame rate.
- **Every screen size:** it has to work from a 360 × 640 phone in portrait to a large desktop monitor, in portrait and landscape. All text, the HUD and the leaderboard fit on screen. Touch buttons never cover the HUD or other text. No page scrolling or zooming.
- **Storage:** use exactly one `localStorage` key, the one named in the message that came with this brief, for the leaderboard and settings. Wrap all storage access in try/catch: the game must still work when storage is blocked.
- **Pause** automatically when the tab is hidden.
- **Reduced motion:** with `prefers-reduced-motion`, drop screen shake and flashing.
- **State for the website:** keep `document.body.dataset.state` set to `title`, `play`, `paused` or `over`. On the title and game-over screens, keep a strip about 56 px high clear at the top centre; the website shows a small "back" link there.
- **No errors** in the browser console. The message that came with it The brief was pasted below this message. Each model got its own storage key, except GPT-6 Astra (see my notes on it).
Please build the browser game described in the brief below.
How this works:
- Work on your own until the game is finished. I won't give feedback or answer questions during the build, so where the brief leaves something open, decide for yourself.
- Write the game from scratch. Don't search local drives, connected repos or the web for existing versions of this game or reuse their code.
- If you can run code or open a browser in this environment, test the game as much as you like before you hand it over. If you can't, check your code carefully instead.
- Deliver the finished game as one complete HTML file. If you can create files, save it as `splash-olympics.html`. If you can't, put the entire file in a single code block. Don't shorten or leave out any part of it.
- Use this localStorage key: `splash-olympics-<model>`
- After the file, write at most five sentences: what you're most proud of, and what you'd improve with more time.
---
[the brief above]