Top 10 Claude Opus 5 Game Prompts (With the Actual Prompts)

Matt Shumer's July 25, 2026 "Claude of Duty" demo did more than rack up views — it made the prompt itself the artifact people wanted. Within days, other builders were posting their own Claude Opus 5 game prompts in full: a Homeworld-style space RTS, a Rocket League clone, a 24-hour Outer Wilds homage, and — the one that had been missing from most roundups — a procedural desert explorer built with a 2,000-word implementation brief, followed by a snow-and-waterbending sequel from the same builder.

This is the builder's version of that roundup: ten real prompts, in the words the builders actually used, what each one produces, and why the structure works. Pair it with Top 10 Claude Opus 5 use cases for the non-game side of launch week.

TL;DR — The 10 Prompts

1. The AAA Quality-Bar Prompt — Claude of Duty

Matt Shumer's now-viral seed prompt, published in full in prompt.md on mshumer/Claude-of-Duty:

I want you to build a first-person shooter at the level of the most recent Call of Duty games. It should be utterly perfect, visually beautiful, with every single thing done at AAA quality—from textures to physics to anything you could think of. Fan out sub-agents and have sub-agents tackle each one individually so that the game is utterly perfect. You should /loop on each item and have a separate sub-agent check it visually to ensure it looks triple A. That separate sub-agent should be a really harsh critic, and if it doesn't look triple A, it should keep going. Don't stop until each sub-agent is utterly wowed with the quality when compared with the actual Call of Duty game. It should literally compare them side by side blind and say which one looks better. Do this in ThreeJS. /loop until it's utterly perfect. Fan out sub-agents and ultracode.

What it produces: an ~55k-line, 11-subsystem browser FPS — rendering, materials, physics, weapons, AI, UI, audio — with zero external art assets, all in Three.js r180.

Why it works: it never asks for a feature list. It sets an unreachable quality bar, assigns a critic role that can't be talked down, and ties the stop condition to a blind comparison against a real reference instead of "does this look okay to you." That structure is what every other prompt in this list borrows. Full technical breakdown — including the two measurement bugs that nearly hid a 12–17 fps stall — in explainx.ai's Claude of Duty decode.

2. The Genre-Swap Prompt — Homeworld-Style Space RTS

Builder @mikeluan123 took Shumer's exact structure and retargeted it a week later:

I want you to build a homeworld style universe scale RTS at the level of most recent space RTS games. It should be utterly perfect, visually beautiful, stunning in detail, with every single thing done at AAA quality... Fan out sub-agents and have sub-agents tackle each one individually... /loop on each item and have a separate sub-agent check it visually... Don't stop until each sub-agent is utterly wowed... compare them side by side blind... Only need random mode, not mission, create multiple ship types, great UI, HUD, and game mechanics, and fluent control, max quality. For ship models, and effects, AAA, max detail needed, use shaders, generative textures, and instancing to ensure best performance.

What it produces: a fleet-scale space RTS with multiple ship types and a HUD, published alongside a token receipt: 68.6k input, 4.6M output, 837.2M cache-read, 13.6M cache-write tokens, totaling $632.65.

Why it works: only the reference game and the closing paragraph changed — shaders, generative textures, and instancing were added specifically because an RTS renders hundreds of ships at once, a load an FPS prompt never has to name. It's the clearest evidence yet that the fan-out/critic/loop skeleton is genre-portable. Full cost breakdown in explainx.ai's Homeworld RTS coverage.

3. The Playable-First Prompt — Rocket Arena

Developer am.will's (@LLMJunky) seed prompt, reconstructed from his thread:

Build a polished browser-based 3D Rocket League–style game using Three.js. First screen is the actual game — no landing page. Use real physics. 1v1 bot mode, real boost/jump/flip feel. After each feature, open the app and play 20 seconds to verify steering and camera.

What it produces: a browser Rocket Arena with car reflections, Rapier physics, boost pads, and bot difficulty tiers — playable at rl-opus5.vercel.app.

Why it works: the acceptance test is embedded in the prompt itself ("play 20 seconds to verify"), and the loop closes with the agent actually driving the finished car to confirm feel — not just running unit tests. See explainx.ai's full writeup for the reproducible eval prompt.

4. The Continuous-Optimization Prompt — The Long Silence

Builder Anshu's approach, documented on github.com/achimala/TheLongSilence, split into two prompt stages instead of one:

Stage 1 (seed): build a Three.js space exploration game at a stable 60 fps in the browser, let the model own all world-building and architecture decisions, avoid a "plastic" visual style.

Stage 2 (24-hour loop): once a playable version exists, issue a continuous optimization goal with multiple sub-agents working in parallel, and a judge sub-agent comparing screenshots against AAA space titles like Starfield.

What it produces: an Outer Wilds-style space exploration game with ship piloting and planetary landings, built from zero to playable in 24 hours with 17 self-authored validation checks, live at longsilence.anshu.dev.

Why it works: separating "get it playable" from "make it beautiful" into two stages avoids the trap of a critic loop fighting an unfinished skeleton — the optimization pass only ever touches a game that already runs.

5. The Implementation-Brief Prompt — Procedural Desert Explorer

This is the entry most Claude Opus 5 game roundups miss. Reddit user Any-Reputation8118 posted a Journey/Dune-inspired procedural desert explorer built with Claude Code on Opus 5 and Babylon.js + WebGPU — a third-person walk through a GPU-clipmap dune field with permanent, eroding footstep deformation, a GPU-simulated hooded robe, a per-pixel physical sky, and six aimed sand spells that dig real craters and raise rideable dunes. Play it at desert-dusky.vercel.app; the builder confirmed it took ~14 hours and ~5 million tokens.

Unlike the Shumer-style one-paragraph seed, this prompt is a full implementation brief — a spec document with hard constraints and gates, not a vibe. The builder's own description of the process: "the original prompt was like 20% of the result, then I was working with Claude incrementally." Structurally, it front-loads two rules that override everything else:

If a requirement in this brief conflicts with making the demo more beautiful, break the requirement. Note the deviation in DECISIONS.md with a one-line rationale... Anything that reads as low-poly, flat-shaded, untextured, placeholder, or "indie prototype" is a defect, not a stepping stone.

It then defines numbered systems (terrain, shading, deformation, atmosphere, character, camera, spells, performance) with measurable pass/fail gates per milestone — e.g., "a static screenshot with no character already looks polished, atmospheric, and production-ready. Do not proceed until this is true" — instead of a single closing "make it good."

Why it works: where the Shumer template relies on a critic sub-agent's subjective blind comparison, this brief replaces most of that subjectivity with objective, per-milestone visual gates and a running decisions log (DECISIONS.md, PERF.md) — closer to a spec than a pep talk. It's the same instinct as Claude of Duty's ARCHITECTURE.md contract, taken further. Full standalone breakdown, including the performance spread across GPUs and the official Three.js repost: Opus 5's procedural desert explorer, decoded.

6. The Sequel-Brief Prompt — SNOWFLOW (Waterbending Demo)

After the desert explorer went viral, the same builder shipped a sequel using the identical brief structure, reskinned: SNOWFLOW, a deformable-snow WebGPU demo with Avatar-style waterbending spells, playable at snowflow-lilac.vercel.app. Built in ~9 hours and ~4 million tokens (not counting cached tokens), the full ~3,000-word brief is public in the builder's Reddit post and on GitHub.

The brief keeps the desert prompt's shape almost exactly — prime directive, hard stack constraints, numbered systems, milestone gates, a performance budget stated in milliseconds — but swaps terrain (dunes → snowdrift), the deformation channels (sand displacement → compression/wetness/ice states), and the five interactive abilities (sand spells → Sweep/Ribbon/Bloom/Crystallize/Vortex water spells).

Why it works — and what to steal: the builder's own summary of the method, when asked how the brief was written: "Write an implementation plan for coding LLM agent. Key points of the game: [insert what you want]. Tech stack is Babylon.js + WebGPU. Avoid GC stutters. [Then] it gives you the plan which often is not quite what you wanted. So you improve on that part as well... I think it took me around 15 messages to get the plan that feels alright." The brief itself is Opus-generated and Opus-refined before a single line of game code exists — the reusable artifact is the brief template, not any single game's prompt.

7. The Iterative-Polish Prompt — Go-Kart Racer

Developer Ryan Campbell's kart racing prototype, per public writeups, started from a straightforward "build a browser kart racer in Three.js" seed and spent most of its iteration budget on follow-ups improving local rendering, mobile performance, steering feel, and camera framing rather than adding new systems.

Why it works: it's a useful counterexample to the fan-out-heavy prompts above — sometimes the highest-value loop isn't more subsystems, it's narrowing repeatedly on feel (steering, camera lag, frame pacing) once the core loop already plays.

8. The Evaluator-Loop Prompt — Claudepunk 2077

Builder Yogi Suria's cyberpunk-style prototype used what's been dubbed a "Challenge Loop": a main agent decomposes the build into parts assigned to specialized sub-agents, and a separate evaluator agent compares the running output against AAA reference games, sending work back for another pass until it clears the bar.

Why it works: it's structurally identical to Shumer's fan-out/critic pattern, generalized into a reusable named process rather than a one-off prompt — useful if you want a template you can point at any genre without rewriting the critic instructions each time.

9. The Non-Combat Mechanic Prompt — Photography Sandbox

Not every Opus 5 game demo is a shooter or a racer. One Reddit-posted build used Godot (not Three.js) to create a photography sandbox — players compose and capture in-scene shots rather than fight or race — built roughly 80% in one session, with a voxel-art style chosen partly to sidestep Opus 5's known weaker spot: hand-authored 3D asset pipelines.

Why it works: picking a mechanic (composition, framing, timing) instead of combat sidesteps the areas — physics tuning, hitboxes, enemy AI — where agentic loops burn the most iteration. It's a useful reminder that "game prompt" doesn't have to mean "shooter prompt."

10. The Fast-Build Public-Link Prompt — Operation Blackout

James Altucher's browser shooter, built and shared as a free-to-play link within roughly 10 hours of Opus 5's launch, prioritized shipping a playable build fast over exhaustive AAA-parity claims — closer in spirit to Anshu's 24-hour Long Silence than to Shumer's open-ended /loop until perfect.

Why it works: a hard time-box (a target number of hours, not "until wowed") forces the agent to prioritize a shippable loop over chasing a critic score that may never plateau — the opposite trade-off from prompt #1.

Honest Limitations

• None of these are one-shot in the literal sense. Every builder here logged hours of follow-up prompts — desert-dusky's builder put it plainly: "the original prompt was like 20% of the result."
• Hardware matters more than the clip shows. SNOWFLOW and the desert explorer both require a WebGPU-capable browser and, per the builders' own benchmarks, a high-end GPU (RTX 5070 Ti-class) to hit target frame rates — commenters on lower-end laptops reported 15–35 fps.
• "AAA quality" is a prompt instruction, not a verified outcome. Claude of Duty's own README admits it doesn't match real Call of Duty; the Homeworld RTS demo has no public repo or independent playable build to verify against.
• Token and time costs vary wildly — from ~4-5M tokens over 9-24 hours (desert explorer, SNOWFLOW, The Long Silence) to a published $632.65 / 4.6M-output-token receipt for the Homeworld RTS. Budget accordingly before promising a client "a game by tomorrow."

What to Steal for Your Own Prompt

1. Pick one structure and commit to it — either a short fan-out/critic/loop seed (Shumer-style) or a long implementation brief with numbered milestone gates (desert-explorer style). Mixing both tends to confuse the stop condition.
2. Tie "done" to a comparison, not a feeling — blind A/B against a named reference game, or a measurable per-milestone screenshot gate, beats "make it look good."
3. Separate "make it playable" from "make it beautiful" into two prompt stages if you can, the way Anshu's Long Silence did — critics fighting an unfinished skeleton wastes loops.
4. Publish the prompt with the demo. Every builder in this list who posted the actual text got dramatically more useful feedback (and credibility) than the ones who only posted a clip.
5. State the performance budget in the prompt, in milliseconds or fps, not "should run smoothly" — SNOWFLOW's brief allocates an explicit 11.1 ms frame budget across systems, which is what let the builder catch and fix GC stutter instead of shipping it.

Related on explainx.ai

• Did Opus 5 one-shot Call of Duty? Claude of Duty, full decode
• Opus 5 built a Homeworld-style space RTS — $632.65 breakdown
• Opus 5 Rocket League clone — then Opus played it
• Opus 5's procedural desert explorer, decoded — full standalone breakdown
• Top 10 Claude Opus 5 use cases
• Claude Opus 5 launch — benchmarks, charts, Fast mode
• Opus 5 for developers — migrate, Fast mode, effort
• Loop engineering — design loops that run while you sleep
• What is an agent harness?
• Thin prompts, thick artifacts, thin skills
• img2threejs — procedural photo to Three.js

Primary sources: GitHub — mshumer/Claude-of-Duty · GitHub — achimala/TheLongSilence · GitHub — am-will/rl-opus · GitHub — Noniv/snowflow_demo · Reddit r/ClaudeAI posts by u/Any-Reputation8118 ("I built a procedural desert explorer with Claude Code (Opus 5) and Three.js" and "People liked my desert, so here's a waterbending demo!") · @mikeluan123 and @LLMJunky on X.

Prompt text, token counts, and build times are as published by each builder between July 24–28, 2026. Demos iterate fast and some (notably the Homeworld RTS) have no public repo to re-verify against — treat completeness claims as the builders' own characterization.