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.
- Claude of Duty matters less as a shooter than as a proof that a hard spec can keep a fleet of agents productive instead of chaotic.
- The repo’s real invention is the Gauntlet Loop, where decomposition, critique, and regression testing turn generation into an engineering process.
- Zero assets and procedural runtime systems are not a gimmick here. They are the architecture that makes the project testable and deterministic.
- The codebase is impressive because it treats browser game development like engine work, even when the final visuals still fall short of AAA polish.
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.
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.
| Dimension | Traditional FPS | Claude of Duty |
|---|---|---|
| Assets | Art pipeline, audio library, hand-authored content | Procedural meshes, textures, and synthesized audio |
| Runtime | Engine plus asset-heavy content bundle | Three.js and WebGL2 with zero external art files |
| Change control | Human team edits multiple disconnected layers | Agent workflow guarded by a critic and tests |
| Proof | Playability and polish | Playability 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.
| Pipeline step | Asset-driven game | Claude of Duty |
|---|---|---|
| Textures | Imported files | Procedural generation |
| Weapons | Modeled and baked | Programmatic geometry |
| Sound | Recorded or licensed | Synthesized in code |
| Iteration | Re-export and re-import | Regenerate 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.
| Question | Loose AI builder | Claude of Duty |
|---|---|---|
| Can output be reproduced? | Usually no | Yes, through deterministic seeds and replayable tests |
| Can regressions be caught? | Often by eye | Yes, with baseline capture and pixel diffs |
| Can agents optimize safely? | Not reliably | Yes, because the harness defines the guardrails |
| Does the system have a memory? | Mostly prompt history | Yes, 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.
| Criterion | Traditional FPS | Typical AI game builder | Claude of Duty |
|---|---|---|---|
| Primary goal | Shipping content | Fast playable output | Managed agentic engineering |
| Asset strategy | External pipeline | Usually prebuilt assets | Procedural and runtime-generated |
| Testing discipline | Team and CI dependent | Often thin | Deterministic visual regression |
| Best use | Production game | Prototype speed | Proof 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.




