“I’m not too sure that many people will compete. So, the expected value of joining is actually pretty high.”
That’s the DM that got me into this. Not “you’re good enough.” Just: most people won’t bother, so the odds are better than they look. I’d already turned the invitation down once. Then Roman did the math at me, and I couldn’t argue with it.
The invitation was a coding challenge he runs: build a video game with a single prompt. One message, sent to an AI coding agent in an empty directory. After you hit enter, you don’t touch anything. No follow-up questions, no course corrections, no “actually, make it blue.” Whatever the agent builds from that one message is your entry. Judges score the game, then break the winning prompt down line by line.
If you’ve used an AI assistant recently, you know how wild that constraint is. Half my interactions are “no, that’s not what I meant” by message three. Getting a whole game out of one message means everything has to be in the prompt before you start: the goal, the architecture, the definition of done, and the answers to questions the agent hasn’t asked yet. The prompt has to steer without a steering wheel.
Three brains
I didn’t sit down and think of a game. I asked three different agents to do it for me.
Same brief to each: a strong game concept for this challenge. Three different harnesses, two different models. And three completely different afternoons.
Both sessions running GLM-5.2 skipped any deliberation and pitched games on the spot. Both, without comparing notes, pitched roguelikes. Hermes Agent came back with Body Snatcher, a possession game where you’re a ghost with one hit point and no attack, and you survive by literally wearing your enemies: twelve of them, each with its own hunting AI and a different move set once it’s your body.
Pi running the same model pitched Underdepths, a classic dungeon crawler in Python: procedurally generated floors, enemies that hunt you through the dark, gear, levels, a dragon at the bottom.
The third session, running GPT-5.6 Sol, behaved like a different species. It opened a full brainstorm first: forced relationships, morphological analysis, SCAMPER, constraint mapping. Twenty-three ideas, developed and narrowed over four structured phases. What survived was Adaptive Loop, a deterministic strategy puzzle about rotating glass rings to route nutrients through a microbial ecosystem that adapts against you. It’s the most original of the three, and I’ll admit I don’t fully understand it while playing it.
Three briefs in, I had three concepts and no way to pick. So I didn’t.
Sixteen runs
From there, everything standardized. Every build ran the same way: Pi, my coding agent, with all my saved skills switched off, running GPT-5.6 Sol. The only variable left was the prompt itself.
August 12 to 16. Sixteen complete runs: five passes on Body Snatcher, four on Adaptive Loop, seven on Underdepths. Each pass was a fresh empty directory, one message, hands off. Between passes I rewrote the prompt and let the corpse of the last run decide what to change.
That cadence, prompt → run → autopsy → prompt, taught me more about directing agents than months of normal back-and-forth work. Because there’s no conversation, every failure traces back to something the prompt failed to say. What the corpses taught me:
Make the agent build its own verifier first. The Underdepths prompt never says “make a game.” Its opening move: “write a test suite that defines done, then write a build pipeline that dispatches each phase of work to a headless copy of yourself, gates every phase behind those tests, and feeds failures back in.” The agent built itself a small factory, and the factory wouldn’t let it ship broken floors.
Specify what must be true, never how. The prompts that worked state pass conditions and boundaries: what counts as done, who may touch what. They never prescribe data structures or algorithms. The moment I told an agent how, it stopped thinking and started transcribing.
Keep the scars. One dead run shipped stairs that existed in the map data but were never drawn—you couldn’t see the way down. The next prompt carried the line “a prior build shipped stairs only in map data, never drawn. Do not repeat that.” Every dead pass left a sentence like that behind. Those scar sentences are the actual prompt engineering.
Pin what the model will otherwise optimize away. Body Snatcher’s spec says, in bold, that enemies must never damage each other. Sounds obvious. But the first builds had bombers and turrets clearing whole floors on their own, and suddenly there was no game—just an arena watching itself. Rules that feel trivial to a human are load-bearing, and the only way to know which ones is to watch a run collapse without them.
The result
Three finished games. A possession roguelike in a single HTML file with zero dependencies. A Python dungeon crawler built by an agent-driven factory that passed every one of its own gates. And a deterministic glass-ring ecosystem I can’t quite master, generated by the one model that brainstormed before it spoke.
The challenge rules say one prompt, one entry. I submitted all three games, one uncut video showing all three being played, and told the judges to pick. The whole thing was one experiment anyway: same brief, same process, three prompts. The code is public in the repo; the prompts went to the judges privately, as the rules require.
I don’t know yet how the challenge shakes out. But the meta-lesson already paid for itself. Roman’s expected-value argument isn’t really about contests. Nearly everything worth entering has a showing-up problem: the field is small because most people talk themselves out of it. I was most people, briefly. Then a two-sentence DM did the math at me.
The odds are better than they look. Enter the thing.
Play them: repo at git.babylondreams.de/AlexKucer…