A browser game with 38,000 lines of code is not unusual. A browser game where every one of those lines was written by an AI agent, across three chapters, with a working melee combat system and zero audio files, is the interesting part.
Long Wind — 长风 — is a 3D wuxia action game by jbang2004, and you can play Long Wind on GitHub Pages without an install. It is the most complete example of agent-built game development we have covered this month, and it is worth studying as a process artifact as much as a game.
Three chapters, three moods
The structure is deliberately small and deliberately finished. Chapter one is a golden grassland with bandit camps and a mini-boss, and it teaches movement, light attack strings and guard. Chapter two is a bamboo forest at night in rain, and it introduces deflect, dodge invulnerability frames and target priority. Chapter three is a lantern-lit long street, and it tests all of it at once.
Each chapter ends on a named boss with a silhouette and an epithet: the Broken Blade, the Night Owl and the Cold Mountain Guest. That naming matters more than it sounds. A boss with a name is a character; a boss with a health bar is a speed bump. The names are the cheapest way to make a short game feel authored.
The visual plan is equally disciplined. One colour script per chapter — gold, blue-green, warm red — with UI kept in an ink-and-paper palette. It is the same restraint that makes Ink Warden read as a coherent world rather than a collection of effects, and it is why the game looks intentional despite being built from procedural geometry.
The combat is a state machine, and you can feel it
Long Wind borrows the vocabulary of modern melee action: light and heavy strings, guard, deflect, dodge with invulnerability frames, posture break and execution. What matters is that the pieces are legible.
Guard absorbs chip damage. A deflect pressed within about 120 milliseconds of impact negates the hit and adds posture damage to the attacker. Miss the window and you get a normal block. Fill an enemy’s posture bar and you can execute. Posture decays when the enemy disengages, so running away is a legitimate way to reset a fight rather than a way to stall forever.
Four enemy types carry the whole game: archers, shield bearers, spearmen and assassins. Each asks a different question. Close the archer, break the shield with heavy attacks, punish the spearman’s recovery, and survive the assassin’s flank. The bosses remix those four patterns instead of adding a fifth rule set, which is why chapter three feels like an exam rather than a new syllabus.
That is a good design even before you consider how it was made. It is also a design that is easy to get wrong: melee combat fails when attack logic lives inside the render loop, and it fails when the deflect window drifts between systems. The build notes say the project ships 30 headless tests, which is the right response to both failure modes.
No audio files at all
The detail I keep coming back to is the sound. There are zero audio files in Long Wind. Every sword hit, deflect, footstep, rain layer, wind bed and crowd murmur is synthesized at runtime with WebAudio.
That is not just a novelty. It means three chapters of content download in seconds, because there is no asset bundle to wait for. It also means the mix can respond to the game state — a deflect can sound different from a block because both are generated, not sampled. And it means the game can run from a single repository with no binary assets to host.
The trade-off is that synthesis is less rich than recorded audio, and a busy fight can turn into noise if the voice count is not capped. Our WebAudio combat soundscape prompt covers the bus structure, ducking rules and voice limits that keep that from happening. It is the part of the build most people will skip, and it is the part that makes the game feel finished.
The build: one agent, 28 hours, 151 files
Long Wind was written by Claude Opus 5.5 running in Claude Code. The developer logged roughly 28 hours of wall-clock work and 19 hours of active work, producing about 38,000 lines of JavaScript and GLSL across roughly 151 files. The only runtime dependency is three.js.
Environment work is procedural: terrain, grass, bamboo, the old town, weather and crowd behaviour are generated rather than modelled. Character animation comes from Mixamo, and some props were generated with Tripo AI. The project is MIT-licensed, excluding third-party assets, and it includes 30 headless tests.
The interesting question is not whether an agent can write 38,000 lines — it clearly can. It is whether the lines hold together. That is a coordination problem, not a generation problem, and it is the reason our parallel-agent build contract prompt exists. When several sessions work at once, the contract that defines module ownership, coordinate conventions, the fixed timestep and the event table is what prevents four incompatible demos from arriving at the same repository.
Long Wind appears to have been a mostly single-session build, which simplifies the coordination problem but does not remove it. Thirty headless tests are the artifact of someone deciding that “it runs” is not the same as “it works.”
What it shares with the rest of the site
The closest comparison on Daily AI Games is Ink Warden, our calligraphy defence game. Both are wuxia-adjacent, both use procedural rendering instead of sprites, both synthesize their audio, and both are built around a single strong mechanic rather than a feature list. Ink Warden’s mechanic is drawing; Long Wind’s is the deflect.
The other useful comparison is BREAKWATER, which is also a large Claude-built game with a compact design frame. Where BREAKWATER solves a spatial puzzle with a tide cycle, Long Wind solves a timing puzzle with a posture bar. Both show the same lesson: scope the systems, not the map.
The caveats
Long Wind is not a commercial game and does not claim to be. The English localisation is machine-assisted, the camera occasionally fights the bamboo, and the difficulty curve assumes you have played an action game before. Three chapters is a short campaign, and the story is thin even by the standards of the genre.
It is also a showcase build. The value is in the demonstration — an agent held a combat system, a chapter structure, procedural environments and a working audio layer in one project and shipped it under an open licence. As a game, it is a good afternoon. As a proof, it is the most useful artifact this week.
At the time of writing the GitHub Pages build had 151 views and the repository had 78 stars. Those numbers are small, but they are the wrong metric for this kind of project. The right metric is how many people read the build notes and try the contract.
What to take from it
Three practical lessons:
- Write the combat state machine before the content. Timing windows, cancels and posture decay belong in a table, not scattered across update functions.
- Treat audio as code. Synthesized sound removes the asset bundle and lets cues react to game state. Cap the voices before it becomes noise.
- Test the timing, not just the boot. Thirty headless checks on deflect boundaries and boss transitions are worth more than a demo that runs once.
Play Long Wind and try to clear chapter two without blocking. Then read the three-chapter wuxia action prompt and decide which of its constraints you would keep. That is the more valuable exercise.