Claude of Duty is a stunning procedural engineering blueprint masquerading as a game
By generating all textures, audio, and meshes from 55k lines of agent-written code, Claude of Duty demonstrates the technical feasibility of zero-asset WebGL builds. However, the jury found a deep divide between its brilliance as a software orchestration experiment and its viability as an actual game engine.
Autonomously generated. This product was selected by the automated daily curation process. The jury evaluation, scores, article text, and publication were generated automatically. No human edited the jury scores or verdict before first publication.
Selection and product details
Jury Summary
Claude of Duty represents an extraordinary technical benchmark: a fully procedural first-person shooter running in Three.js and WebGL2 without a single traditional image or audio file. By delegating the creation of its 19 procedural surfaces, atmospheric scattering, and custom physics solver to an orchestrated fleet of AI agents, it bypasses the bandwidth and asset pipelines that typically weigh down web-based gaming. The jury's consensus is that while the project fails its stated ambition of matching a modern Call of Duty in visual fidelity—rendering instead with the flat, noisy aesthetic of an amateur demo—the underlying developer tooling and optimization harness are deeply impressive. In particular, the custom profiling script and shader pre-warming system solve a notoriously difficult WebGL problem: eliminating the multi-hundred-millisecond hitching caused by lazy mid-frame shader compilation. But the project's long-term utility split the jury. For game developers looking to ship WebGL applications, the coupled 55k-line JavaScript codebase presents a maintenance risk, as agent-generated architectures are difficult to refactor or extend without breaking hidden assumptions. For systems engineers and AI researchers, however, it serves as a valuable blueprint for multi-agent software engineering, showing how strict subsystem boundaries can produce complex, performant systems.
WHERE THE JURY AGREED
- ✓
The zero-asset procedural model is an outstanding demonstration of load-time texture and sound generation, which reduces initial asset downloads to zero.
- ✓
The profiling harness and shader pre-warming implementation are highly effective at solving real-world WebGL performance bottlenecks like mid-frame compilation hitching.
- ✓
The custom physics and collision engine, written from scratch without external libraries, demonstrates exceptional mathematical and engineering discipline.
WHERE THE JURY SPLIT
- purpose usefulness
Alex and Marcus argue that Claude of Duty is a low-utility novelty since it cannot be used as a foundation for a commercial game, while Sarah and David contend that its value lies in its role as a blueprint for orchestrated agent-driven development.
Five Jury Perspectives
Five simulated professional perspectives scored the same public evidence using the JuryPress Open Product Rubric.
Alex
Serial Entrepreneur
Claude of Duty is an impressive tech demo, but as a product, it is a dead end. On Monday morning, no game studio is going to pull this down to build a real business because the visual assets are flat and the code is too complex to refactor. It is a brilliant showcase of what AI agents can build, but its actual commercial utility is near zero.
- Instant onboarding with a simple two-command setup that launches the engine immediately.
- The procedural asset concept eliminates massive bandwidth costs for web games.
The procedural texture ceilings look noisy and amateurish, failing to provide a commercial-grade user experience.
View full scorecard
The project's stated goal of matching a modern commercial FPS is unmet. While it works as a demonstration of procedural generation, it has no direct utility for game studios looking to ship a real product.
The codebase is fully runnable with standard node commands, and the live demo works as described.
The sheer volume of code is impressive, but the tight coupling of the rendering, sky, and light systems makes it extremely fragile for future product development.
There is virtually zero friction to get the game running locally. The readme commands work perfectly out of the box.
Building a complex FPS with zero traditional art assets through sequential agent orchestration is a highly novel approach that differentiates it from every other Three.js template.
The project is a snapshot of an AI experiment. There is no active community, no issue management system, and no path for long-term product stewardship.
David
Principal Software Engineer
Architecturally, the custom systems in Claude of Duty are outstanding, particularly the binned-SAH BVH physics solver in src/physics and the shader pre-warming in src/core/prewarm.js. However, the agent-written JS files contain coupled concerns that will make long-term maintenance by human developers difficult. It is a strong showcase of mathematical engineering built under unique constraints.
- The custom physics engine uses a binned-SAH BVH that handles 29k triangles in 22 milliseconds with high-efficiency raycasting.
- The shader pre-warming script eliminates WebGL compilation stalls completely during gameplay.
The rendering pipeline is tightly coupled to the sky and ambient lighting, causing changes in one system to break visual assertions in others.
View full scorecard
For engine developers, the repository serves as a reference for Three.js optimization. For practical game development, it is too monolithic.
The profiling, baseline capture, and imagediff tools are fully implemented and verified in the codebase.
The custom swept-capsule character controller and binned BVH physics are high-quality, high-performance implementations that bypass standard sluggish JS libraries.
- Confidence limited to medium: 5 of 173 source files were examined, a sample of the codebase. The examined files bear on execution & permission safety, cost & resource controls, production reliability; data write safety were not examined.
The tooling scripts are robustly written, and the developer console outputs clear, actionable performance metrics.
Writing custom rigid-body physics, PBD ragdolls, and procedural sound synthesis in Web Audio without external runtime libraries is a remarkable engineering achievement.
The codebase is a static drop under an MIT license. It lacks automated test suites or a structured branch model, suggesting it will not be actively maintained.
Lisa
Head of Product Design
The installation process is incredibly smooth, and the developer ergonomics of the headless testing harness are excellent. From a UX perspective, however, the game itself fails to deliver on its aesthetic promises; the hands are blocky slabs and the procedural materials look like noise at close range. It functions beautifully as a developer playground, but not yet as an immersive experience.
- Excellent first-run installation with a clean npm start process that requires no external assets.
- The DOM and CSS HUD layout is highly intuitive, placing the health widget and plates in a clear, findable screen area.
The visual interface suffers from aesthetic compromises, notably the blocky finger geometry that breaks weapon immersion.
View full scorecard
It is highly useful as an educational project to study how DOM overlays interact with WebGL canvases, but the actual gameplay UX is not ready for a consumer audience.
The visual assets compile on-the-fly and run flawlessly at 30fps without missing layers or broken assets.
The health UI in src/ui/health.js uses elegant SVG filters and dampening, but the underlying rendering pipeline is hampered by flat global illumination approximations.
Setting up the project is exceptionally simple, and the keyboard control mappings are highly intuitive.
Generating textures and sounds procedurally via Web Audio and custom noise maps is highly creative, though the resulting fidelity has clear ceilings.
There are no contribution guidelines or interface change logs, leaving future developers on their own to decipher the agent-written code.
Sarah
Senior Product Manager
Claude of Duty has a clear, highly constrained scope: build an FPS with zero traditional art assets using orchestrated AI agents. It meets this technical constraint impressively, but fails its secondary goal of matching a modern Call of Duty. As a product manager, I see this as a valuable architectural blueprint for AI generation, but not a viable product roadmap.
- Highly coherent project scope with a strict 'no art assets' constraint that is perfectly maintained across all subsystems.
- The baseline screenshot tool provides a reliable, bit-identical visual gate for regression testing.
A severe lack of roadmap transparency or release versioning makes it difficult to plan any upstream adoption.
View full scorecard
The scope is narrow and well-defined. If evaluated as a showcase of asset-free WebGL games, it succeeds, but it is not a direct replacement for standard commercial game templates.
The repository contains real, functional testing scripts like playtest.mjs that successfully verify system behavior.
The codebase has strong architectural modularity, but the decision to write custom physics instead of using established libraries represents a massive maintenance trade-off.
The documentation in the README and ARCHITECTURE.md is exceptionally clear about subsystem responsibilities and boundaries.
The choice to restrict all assets to pure code is a highly differentiated constraint that forces unique engineering solutions.
While the license is a clear MIT, the project lacks versioned releases, a changelog, or an active issue triage process.
Marcus
Venture Capitalist
This is a fascinating engineering experiment that pushes the boundary of what AI orchestration can achieve in the WebGL ecosystem. It bypasses traditional WebGL asset distribution bottlenecks, which could inspire a new class of low-bandwidth web experiences. However, without a community ecosystem or active maintainers, it risks becoming another abandoned high-star repository.
- Highly differentiated procedural generation model that completely bypasses the traditional 3D web asset pipeline.
- Massive developer attention with over 2,200 stars within a very short timeframe.
The lack of community infrastructure or contributor guidelines prevents ecosystem leverage and growth.
View full scorecard
The direct utility is limited since it sits in isolation without clear SDK integrations or modular package exports.
The execution is verified by a functional local build, though we lack automated multi-platform CI verification.
The custom implementations are impressive but risk fragmentation, as they do not leverage or benefit standard industry frameworks.
The fast-start design allows rapid assessment, which is excellent for developers looking to audit the repository quickly.
This is a highly disruptive demonstration of prompt-driven multi-agent systems engineering that has no close parallel in the open-source WebGL ecosystem.
With only a single commit push and no community-focused PR management, the project's long-term survival is highly questionable.
Final Verdict
If you are a web developer or games engineer looking to solve WebGL startup compilation stalls, you should clone Claude of Duty immediately to study its shader pre-warming and profiling scripts. If you are a team lead planning a commercial game, you should skip this codebase entirely, as maintaining 55k lines of agent-written JavaScript with coupled systems will create severe technical debt. Our endorsement of its optimization patterns depends on its proven performance under Retina-level resolutions. We would only recommend this as a production starting point if the maintainers modularize the subsystems and establish a standardized community contribution framework.
Evidence reach: the jury examined 5 of 173 source files, including implementation bearing on execution & permission safety, cost & resource controls, production reliability. Not examined: data write safety.
Bring the jury to your own project
Run the same five AI personas with your own evidence and evaluation criteria using Judgie-AI.
Explore Judgie-AI →Sources, evidence map and generation metadata
Sources
- ev-dc4c6b7f: mshumer/Claude-of-Duty GitHub API Metadata (api_metadata)Retrieved: 2026-07-29T23:01:08.213Z
- ev-4af5a943: mshumer/Claude-of-Duty README (readme)Retrieved: 2026-07-29T23:01:08.256Z
- ev-2237d767: Dependency Manifest (package.json) (dependency_manifest)Retrieved: 2026-07-29T23:01:08.463Z
- ev-0a971a6f: Core Source File (main.js) (source_code)Retrieved: 2026-07-29T23:01:08.608Z
- ev-fb2ef2d1: Core Source File (index.js) (source_code)Retrieved: 2026-07-29T23:01:08.816Z
- ev-a63efad0: Core Source File (index.js) (source_code)Retrieved: 2026-07-29T23:01:09.007Z
- ev-02e1d6d8: Targeted Source File (agent.js) (source_code)Retrieved: 2026-07-29T23:01:09.184Z
- ev-73272773: Targeted Source File (health.js) (source_code)Retrieved: 2026-07-29T23:01:09.245Z
- ev-b2da9be9: mshumer/Claude-of-Duty (official_site)Retrieved: 2026-07-29T23:01:09.902Z
What the jury could not assess
- The jury could not assess the direct multiplayer scalability or real-world network synchronization, as the repository lacks multiplayer infrastructure.
- The long-term maintainability of the agent-generated codebase could not be evaluated due to the absence of continuous integration logs or active community development branches.
How claims relate to sources
After this review was written, a separate pass recorded how its statements relate to the collected material. It is a record of the writing, not a score of it: opinions and comparisons are expected to be the jury's own.
This record covers the review's narrative — the summary, headline, standfirst, jury summary, points of agreement and disagreement, stated limitations, verdict, and each judge's verdict and leading concern — plus any specific factual claim made elsewhere, such as a figure, a security or runtime assertion, or a claim about what the project lacks. The per-criterion scoring commentary is not mapped statement by statement: an opinion about a score is the jury's judgment, not a claim about the world. All 72 covered statements were recorded.
- Directly supported1 statement
- Repository observation15 statements
- Creator claim17 statements
- Editorial judgment39 statements
Statements recorded as more than one claim
These sentences assert more than one thing, and the collected material does not cover every part equally. Each part is recorded separately so that a well-sourced half does not stand in for the whole. Where the parts differ, the statement is counted at the strength of its weakest factual part.
- “Claude of Duty is an experimental web-based first-person shooter written by an orchestrated fleet of AI agents with zero traditional art assets.”
- Claude of Duty is an experimental web-based first-person shooter written by an orchestrated fleet of AI agents
- with zero traditional art assets.
Generation metadata
- Model: gemini-3.5-flash
- Prompt version: 4.4.0
- Rubric: open-source-product 2.0.0
- Scores recalculated by code: yes
- Editorial provenance: Autonomously generated
- Evidence record: complete — 72/72 covered statements (28 scoring statements out of scope)
Discuss this review
Disagree with the verdict or found evidence we missed? Share a reasoned response, public evidence, or a factual correction.
Comments are public and require a GitHub account. Comments do not automatically change the jury score. Verified corrections may be reflected separately in Corrections & Updates.
Open GitHub Discussions