Shadow Blade Duel: what one model ships when the brief keeps changing.
Can a single agentic model carry a complete action game from an empty folder to a finished build, not in one shot, but across the messy way real products evolve? We gave Kimi K3 one opening brief, a stickman sword fight for desktop and mobile, then played it, found it wanting, and revised the brief twice. This report records what the model carried on its own, where it needed us, and the evidence rig that makes every screenshot re-capturable.
The Finding
Lead with the answerOne model can build the whole game, and rebuild it, but it learns what fun means only from the human's playtest. Across a single day, Kimi K3 produced a complete, dependency-free action game: about 6,300 lines of strict TypeScript, a hand-rolled Canvas 2D engine with fixed-timestep combat, verlet ragdoll physics, procedural ink-wash scenery for 30 distinct levels, a six-blade progression system, six scripted bosses, and a fully synthesized Web Audio soundscape, with zero image or audio asset files. More telling than the output was the loop: the model worked in long autonomous windows, three consecutive 60-minute runs on the first pass, resuming its own context each time, and kept the build green through every revision. When a human playtest surfaced a show-stopping AI freeze, the model not only fixed the root cause but built a headless simulation harness that proves the entire class of bug stays fixed. What no run of the model produced on its own was the game's identity: the demand for agility, the ink-on-paper art direction lifted from a reference image, the blade-progression spine, and the studio branding. The model built the machine. The taste, the feel, and the product calls stayed ours.
The question
Can one agentic model carry a complete action game through the real cycle of playtest-driven revision, and what does it still need a human for?
The subject
Kimi K3 inside an agent runtime with subagent execution, file tools, shell, and headless verification, directed and playtested by a human owner.
Not a claim about
Model rankings, other genres, unsupervised quality, or one-shot generation. One game, one recorded day, three human-directed revisions.
Under Test
Stack and environmentThe Account
How it was built and what happenedA game a player would finish, not a demo.
The opening brief was deliberately player-facing: a 2D stickman sword fight with progression through difficulty steps, sword noise, graphics, and scenery, exciting and addictive, playable with equal ease on desktop and mobile. No engine, no assets, and no framework were prescribed. The model chose the stack, designed the combat, and shipped a first complete pass: ten levels, two bosses, upgrades between levels, parry and dash mechanics, hit-stop, screen shake, slow-motion kills, procedural audio, and touch controls, with the build green and smoke-tested behind it.
Then the experiment did what real ownership does. We played the build, found it wanting, and changed the brief twice: once to fix the feel and set the art direction, and once to expand the game into a 30-level campaign with a blade-progression spine and clean studio branding.
Autonomy measured in hours, not prompts.
The first pass was built by a coding subagent across three consecutive 60-minute autonomous windows, the runtime's per-run ceiling, with the agent resuming its own prior context each time rather than starting over. Inside those windows the model made hundreds of independent decisions: engine architecture, animation poses, AI state machines, difficulty curves, synth patches, and mobile ergonomics.
The human contribution to pass one was twelve sentences of brief and one approval queue. This is the working pattern the experiment set out to probe: not autocomplete and not chat, but a model left alone with a folder, a test runner, and a definition of done.
- Three consecutive 60-minute autonomous runs on the first pass, context resumed each time
- Strict-type build gates kept green through all three revisions
- A human review gate and playtest between every revision
A combat system with real depth, measured.
The shipped game is a 30-level ink-on-paper sword campaign. Fifteen-plus distinct techniques, including a three-swing combo, a charged guard-breaking heavy, a launcher into air juggles, an iaijutsu dash-strike with delayed damage and a slow-motion beat, timed parries, cinematic ripostes, blade clashes, and executions, all run as procedural animations on a hand-rolled skeletal rig. Six enemy archetypes with genuinely different behaviors meet six scripted bosses, including a two-phase final master, and verlet ragdoll deaths launch bodies across the screen under a style-rank meter that grades the fight from D to SSS.
The blade-progression system unlocks a named katana at each boss: attack speed, burn, slow, chain lightning, and raw damage, each re-skinning the player's blade, trail, and aura in-engine and persisting locally. The whole build holds at roughly 352 KiB minified, about 110 KiB gzip, with zero asset files beyond the Zorost mark.
The model never once said it feels wrong.
Every defining correction in the record came from a human playing the build. The first playtest found what all of the model's own smoke tests had missed: enemies froze after a few exchanges, because a dead fighter's update returned early, its corpse timer never advanced, and wave completion silently never fired. The human also rejected the feel, demanding agility and a hero who actually jumps, and supplied the identity: a reference for acrobatics and a single image of a hand-drawn stickman battle on notebook paper that became the game's entire ink-wash art direction.
The second playtest drove the expansion to 30 levels with blade progression, and a business call no model would make: strip every decorative glyph from the build and brand it cleanly as developed under Zorost Intelligence AI Lab. Each note was mechanical to apply once named. Naming them took a person with thumbs on the game.
Screenshots you can re-capture, not screenshots you have to trust.
To document the build honestly, the game carries a small set of URL affordances: a level parameter that jumps to any of the 30 levels, an attract mode where a simple bot pilots the player, an autostart flag, a full-armory unlock for capture sessions, and a switch that forces the mobile interface. Every image in this report was captured with headless Chrome against the live build using those affordances.
Any reader with the build can reproduce each frame: same URL, same virtual-time budget, same shot. Evidence you can re-run, not evidence you have to take on trust.
From the Field
Captured from the live build
What Held, What We Flag
Wins and limits, side by side- The full loop shipped and re-shipped: three major revisions in one day, with the build green after every one, strict types, zero errors, and the bundle steady around 352 KiB minified with zero asset files.
- The autonomy is real: three consecutive 60-minute runs on pass one, the agent resuming its own context, and hundreds of decisions later verified by gates and playtests.
- The model's verification earned its place: the headless simulation runs the real engine through all waves including bosses, with an AI-stall watchdog and blade-unlock assertions, and passed three consecutive runs.
- Mobile is first-class: a joystick, a four-button action cluster, portrait and landscape handling, and a DPR-crisp canvas.
- The evidence rig travels with the build: every screenshot in this report is a documented URL away from being re-captured.
- Game feel stayed human. Agility, art direction, the progression spine, and branding, the four things that define this game, all arrived as human notes after playtests.
- The freeze bug passed the model's own smoke tests and was found by a person playing for under five minutes. The model then fixed it well, root cause plus a regression harness, but it did not find it.
- Balance is unmeasured. Difficulty tuning is by feel, not playtest data, and the late-game curve from level 20 to level 30 has not been human-verified.
- One model, one genre, one day. This is a dated field record, not a ranking, and not a claim that the next brief would go the same way.
Measurements
Enforced on every build- Model under test
- Kimi K3, agentic subagent runs
- Build window
- One day, three human-directed revisions, July 2026
- TypeScript produced
- About 6,300 lines, 18 source files
- Levels and bosses
- 30 procedural ink-wash scenes · 6 bosses
- Initial JS and CSS (gzip)
- About 124 KiB
- Headless sim test
- All waves including bosses, 3 of 3 consecutive passes
- Human code written
- 0 lines
The model built the machine. The feel stayed human.
Disclosures
What a careful reader deserves- All game code was written by the model under test. It entered the build only through its own type checks, build gates, and simulation tests, under a human owner's direction. No human wrote code in this experiment.
- Human playtests drove three revisions. Every design note quoted in this report is from the recorded session.
- The game runs entirely in the browser. Progress, unlocks, and settings persist in local storage on the player's device. The build collects no personal data.
- All art and audio are original and procedural. No third-party assets ship in the build.
- The build is proprietary, so the source tree is not public. This report and the live experiment are the published evidence.
- Vendors and models are named as test subjects only. This is a dated field record, not an endorsement and not a product claim.
Go Deeper
Run it · read it · build on itServing those who
need to stay ahead.
We don't pitch slide decks. We show you what we've already built in your domain, then engineer what your mission requires.