Claude of Duty: How a One-Prompt FPS Became a Testbed for Agentic Game Engineering

A browser shooter built with Three.js, WebGL2, and zero external assets, where the bigger story is the agent workflow, the procedural pipeline, and the ruthless regression testing that keeps it all standing.

9 min read • View on GitHub • More from mshumer

A wide machine-room scene shows a browser FPS being assembled from separate subsystems, with task lines feeding rendering, physics, audio, weapons, UI, and world modules into a central blueprint. Small agent figures hand down instruction cards while an inspector rejects imperfect output at the edge of the frame. The image explains that the project is really about coordination and critique, not just a shooter.
The game is the proof object. The workflow is the invention.
Key Takeaways

The real product is the workflow

Claude of Duty is easy to misread as a novelty demo: an AI-made FPS, rendered in the browser, with a name that invites screenshots. That is the least interesting thing about it. The real subject is the machine that built the game, and the discipline needed to keep that machine from drifting into mush.

The interesting part of this repo is arguably the harness, not the game.

Matt Shumer, Creator / CEO of HyperWrite · GitHub - mshumer/Claude-of-Duty

The Gauntlet Loop is the organizing idea. A goal becomes a shipped subsystem only after decomposition, critique, and regression tests all agree.

Why a browser FPS is the perfect stress test

An FPS is a brutal target for agentic coding because it forces too many systems to cooperate at once. Rendering, physics, animation, input, audio, combat feel, and performance all have to land together. If one layer slips, the whole illusion collapses.

DimensionTraditional FPSClaude of Duty
AssetsArt pipeline, audio library, hand-authored contentProcedural meshes, textures, and synthesized audio
RuntimeEngine plus asset-heavy content bundleThree.js and WebGL2 with zero external art files
Change controlHuman team edits multiple disconnected layersAgent workflow guarded by a critic and tests
ProofPlayability and polishPlayability plus deterministic regressions

That makes the browser a sharp proving ground. If an agent can survive the browser’s limits, it can probably survive a much wider range of real software constraints.

The no-assets rule changes everything

The project does not lean on the usual safety net of downloaded models, sounds, or textures. It generates what it needs at runtime. That changes the economics, but more importantly it changes the architecture, because the code has to own the look, the feel, and the performance budget all at once.

A split editorial scene contrasts a cluttered asset pipeline on the left with a clean procedural forge on the right. The left side has crates, file folders, texture sheets, and audio reels stacked into a slow assembly line. The right side shows a compact engine turning math, noise, and synthesis into surfaces and sounds with far fewer moving parts. The image explains how procedural generation replaces the usual art pipeline.
No assets is not just cost-cutting. It is a different software architecture.
Pipeline stepAsset-driven gameClaude of Duty
TexturesImported filesProcedural generation
WeaponsModeled and bakedProgrammatic geometry
SoundRecorded or licensedSynthesized in code
IterationRe-export and re-importRegenerate and test

Inside the engine contract

The codebase is organized like an engine team wrote the rules first and the content second. A central Engine orchestrates systems through a registry that sorts dependencies before startup. That lets the project keep a lot of agent-authored subsystems from turning into a tangled import graph.

// Simplified from the engine pattern
class Engine {
  start() {
    this.registry.sortByDependencies();
    this.registry.initAll(this.ctx);
    requestAnimationFrame(this.tick);
  }

  tick = (time) => {
    this.fixedUpdate();
    this.update();
    this.lateUpdate();
    requestAnimationFrame(this.tick);
  };
}

That matters because the repository is not a one-off script. It is a place where many generated systems have to cooperate without leaking responsibility into one another. The frame loop and registry turn a messy language model output into something closer to software.

Rendering like an engine team wrote it

The rendering stack is where the project starts looking less like a prompt experiment and more like a serious browser engine. Materials are patched to support advanced lighting features, the viewmodel is rendered in its own scene to avoid clipping and ghosting, and shader warm-up prevents the browser from pausing mid-play to compile GPU permutations.

That separation is a small detail with big consequences. The weapon can behave like a first-class object without contaminating the rest of the camera pipeline, which is exactly the kind of decision that makes a browser FPS feel intentional instead of improvised.

The physics and testing stack are the real proof

If the visuals are the lure, the testing story is the evidence. The project leans on deterministic RNG, headless baseline captures, and image diffs so a change can be checked against its previous behavior. That is the opposite of vibe-only development. It is a refusal to let AI-assisted iteration become unbounded drift.

QuestionLoose AI builderClaude of Duty
Can output be reproduced?Usually noYes, through deterministic seeds and replayable tests
Can regressions be caught?Often by eyeYes, with baseline capture and pixel diffs
Can agents optimize safely?Not reliablyYes, because the harness defines the guardrails
Does the system have a memory?Mostly prompt historyYes, via test artifacts and reference frames

That is why the repo feels like a benchmark, not just a game. It proves that a fleet of agents can be pointed at a hard target and still be judged by something stricter than enthusiasm.

What this beats, and what it does not

Against a conventional asset-driven FPS, Claude of Duty looks austere. Against typical prompt-to-playable tools, it looks overengineered. That is exactly the point. It is trading breadth of convenience for depth of control.

CriterionTraditional FPSTypical AI game builderClaude of Duty
Primary goalShipping contentFast playable outputManaged agentic engineering
Asset strategyExternal pipelineUsually prebuilt assetsProcedural and runtime-generated
Testing disciplineTeam and CI dependentOften thinDeterministic visual regression
Best useProduction gamePrototype speedProof of method

The limit is just as important as the achievement. This is not yet a replacement for a seasoned AAA team, and the project does not pretend otherwise. It is a strong technical experiment, a public benchmark, and a useful argument for disciplined agent workflows.

The bigger bet

The lasting idea here is not that AI can make a shooter. It is that a hard spec, a strict runtime contract, and a ruthless critic can make AI useful on complex software. That is a stronger claim, and a more durable one.

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.

Matt Shumer, Creator / CEO of HyperWrite · Claude-of-Duty/prompt.md