Fable 5.1 vs GLM 5.3 vs Kimi K3: we built the same bird flap game with all three

Same prompt, three models, one shot each, no follow-up prompts. This is part of an ongoing series where we run /design in Command Code against every model we can get our hands on, then read the generated code line by line instead of just eyeballing the screenshot.

This round: Fable 5.1, GLM 5.3, and Kimi K3, all asked to build the same bird flap game.

The prompt

Create a complete single HTML file for a cute bird flap game using Canvas. Smooth gravity, flapping animation, parallax background, score, pipe obstacles, game over screen

One shot. No corrections, no re-rolls. Whatever came back is what got graded.

Every model that generated a build

This prompt has been run against 29 models in total. Full field, so nothing here is cherry-picked:

Cost figures are user-reported or formula-estimated per this repo's own methodology, not independently metered - treat them as directional, not invoices. * The table's LOC figure for Fable 5.1 (641) doesn't match a direct wc -l on the kept file (414, below) - likely a stale carryover from an earlier revision of the source table. We're flagging the discrepancy rather than picking one silently.

Verified feature matrix: all 29 models

Mechanically checked across every build in the directory - grepped for localStorage, a clamped circle-vs-rect collision helper, mute, a JS resize listener, devicePixelRatio, and a Google Fonts <link>. This is presence/absence, not a quality judgment - it tells you what a model attempted, not how well. The four models with a full narrative read above, plus the four pulled from this repo's own prior passes below, are the only ones with a craft judgment attached; everything else here is a mechanical signal only.

A few things jump out even from presence/absence alone: persistence is now the norm, not the exception - 26 of 29 builds save a best score, and the three that don't (Fable 5, Opus 5, Laguna S 2.1) span a cheap model and two expensive ones, so it isn't a cost story. The exact clamped circle-rect collision test has spread well beyond the three models that originally converged on it - roughly half the field now uses some form of it. Offline-safety splits closer to even than either extreme: 16 of 29 make zero network requests, 13 pull a Google Fonts stylesheet, with no obvious pattern by vendor - GLM, DeepSeek, and Grok all have entries on both sides of that line.

This post does a full narrative read of four of the twenty-nine: Fable 5.1, GLM 5.3, Kimi K3, and (added below) Qwen-3.8-Max. This repo's own prior passes add narrative findings for four more - GLM 5.2, DeepSeek V4 Pro, GPT-5.6 Sol, and Opus 5 - summarized in a section below. The remaining twenty-one are covered by the mechanical matrix above only; a full line-by-line read of the rest is the natural next update to this post.

Method

Static read for the four models covered in depth: files opened directly and read end to end, findings cited by file and line number.

Fable 5.1 shipped roughly half the code of the other two. That's worth keeping in mind for every finding below - it isn't cutting corners so much as making different calls about what a "cute bird flap game" needs.

Which model should you reach for

If you want the most complete build with no follow-up prompt, GLM 5.3 is the safest default here - it's the only one of the three with a mute control, a difficulty ramp, and full offline-safety in the same build. If you're optimizing for the smallest, easiest-to-audit codebase, Fable 5.1 gets remarkably close to the same player experience at roughly half the code. Kimi K3 sits in between: it matches GLM 5.3 almost feature-for-feature, at the cost of one network font request.

None of that is guessable from a screenshot or a marketing page - it only shows up once you run the same brief against each model and actually compare what came back. That's the reason to keep /design in Command Code in your workflow: one CLI, any model, the same prompt, so picking a model for your next AI-generated game or app is a five-minute test instead of a guess.

Verdict

For a build that's roughly half the size of the other two, Fable 5.1 is not obviously behind on the things a player would notice - smooth gravity, working parallax, a working restart loop, DPR-correct resize, a persisted best score. What it gives up is polish under the hood: an approximate collision box instead of an exact one, a flat difficulty curve, no mute control, no medal tiers. None of that is a bug, it's just less feature surface for less code.

GLM 5.3 and Kimi K3 converge on almost the same feature set - exact collision math, a difficulty ramp, medal tiers, persisted best score - which is itself the interesting result: two different labs' models independently landed on the same clamped circle-rect formula and the same "shrink the hitbox for forgiveness" trick. Where they actually split is accessibility and cost-to-load: GLM 5.3 is the only one of the three with a real mute toggle, keyboard-focus styling, and a prefers-reduced-motion guard, and it does all of that while staying fully offline-safe. Kimi K3 matches it almost everywhere else but reaches out to Google Fonts for a typeface GLM gets the same fallback-driven look without downloading.

If you're picking by "closest to shippable without a follow-up prompt," GLM 5.3 edges it on completeness and offline-safety. If you're picking by "most game for the least code," Fable 5.1 is the one to look at.

Update: Qwen-3.8-Max also beats Fable 5.1 on both cost and feature depth

We went back and read a fourth build on the same prompt: Qwen-3.8-Max (qwen-3.8-max/index.html, 1,128 lines). Same one-shot rules, no follow-up prompts.

Qwen-3.8-Max matches GLM 5.3 and Kimi K3's exact clamped circle-rect collision test (circleRect(cx, cy, r, rx, ry, rw, rh) with the same clamp-based formula, line 332), and goes a step further than all three original models on physics rigor: it runs a genuine fixed-timestep accumulator at 120Hz (const STEP = 1 / 120, line 1110) rather than a single 60Hz step or an unclamped variable-dt loop.

It also ships two things none of Fable 5.1, GLM 5.3, or Kimi K3 have:

• A real pause feature. KeyP toggles S.paused, with a dedicated dimmed pause overlay (drawPauseOverlay, line 945).
• Auto-pause on tab hide. document.addEventListener('visibilitychange', () => { if (document.hidden && S.mode === 'playing') S.paused = true; }) (line 1087-1089) - the game can't keep running physics in a backgrounded tab.

It has the same medal-tier system and persisted best score as GLM 5.3 and Kimi K3 (localStorage, key flappy-chick-best), a canvas-drawn mute button with its own mute state persisted separately (flappy-chick-mute), and listens for both resize and orientationchange for its DPR-aware fit - one more event than any of the original three. Like Kimi K3, it pulls "Baloo 2" from Google Fonts over the network, so it isn't offline-safe.

Per the readme's cost table, Qwen-3.8-Max's single-generation floor is ~$0.025 - about 16x cheaper than Fable 5.1's ~$0.40, while shipping a deeper feature set (pause, auto-pause-on-blur, 120Hz fixed timestep) than Fable 5.1's leaner, cheaper-to-read 414-line build. That's the same pattern Kimi K3 showed against Fable 5.1 above: on this prompt, the two cheapest builds in the set are also the two with the most complete feature checklists.

What the wider field shows: GLM 5.2, DeepSeek V4 Pro, GPT-5.6 Sol, and Opus 5

Four more models from the full 29-model field above have already been through a line-by-line read in this repo's own benchmark history, and the pattern holds:

• Collision: GLM 5.2, GPT-5.6 Sol, and Kimi K3 all independently converge on the same clamped circle-vs-rect distance test, with GPT-5.6 Sol and Kimi K3 each applying their own forgiveness margin on top of it. Fable 5 and Opus 5 both approximate the circle as a shrunk AABB instead - cheap and fine, just less exact. DeepSeek V4 Pro uses the bird's full visual bounding box with no forgiveness margin at all: correct, but the least tuned collision box in the set.
• Confirmed resize bug, DeepSeek V4 Pro: its canvas backing store is fixed at 420x640 with no resize listener anywhere, while its own CSS switches the wrapper to full-viewport sizing under 440px width - any modern phone stretches the fixed-aspect canvas non-uniformly.
• Resize handling overall: Kimi K3 does the most thorough job - a virtual-resolution resize that scales the canvas backing store by device pixel ratio and remaps drawing coordinates, plus the only one of the group that resets its frame-timing reference on tab visibility change. GPT-5.6 Sol takes a different, CSS-only route (no JS resize listener, no DPR scaling, an aspect-ratio wrapper instead) that avoids DeepSeek's distortion bug but never sharpens on high-DPI displays. Opus 5 lands closest to Kimi K3: it scales the backing store by DPR capped at 2.5 - the only build in this wider set that bounds DPR at all, which stops a 3x-DPR phone from allocating an oversized buffer for a small game.
• Audio and mute: GLM 5.2, Kimi K3, and Opus 5 all synthesize sound via AudioContext. GLM 5.2 and Opus 5 are the only two with an actual mute toggle; Kimi K3's sound has no in-game way to turn it off; GPT-5.6 Sol ships no audio at all.
• Persistence: GLM 5.2, DeepSeek V4 Pro, GPT-5.6 Sol, and Kimi K3 all persist a best score via localStorage. Fable 5 never persists a best score. Opus 5 has the more interesting gap: it tracks and displays a "best" score on the game-over card, even firing a "new best!" banner, but the variable is plain in-memory state - there's no localStorage call anywhere in the file, so the UI promises persistence the code doesn't deliver.
• Offline-safety is a 3-3 split across this group: Fable 5, GLM 5.2, and Kimi K3 all pull a Google Fonts stylesheet over the network; DeepSeek V4 Pro, GPT-5.6 Sol, and Opus 5 make zero external requests.

Weighed on quality-per-dollar across this wider group, Kimi K3 remains the standout: roughly 2x cheaper than GLM 5.2 for a build that matches it on collision, architecture, and resize robustness, giving up only the mute control and the offline-safety tie. GLM 5.2 has the highest raw quality mean in this six-model group, but the gap over Kimi K3 is thin enough that it isn't a clear win once price enters the picture.

Try this yourself

This whole comparison is one Command Code session per model, same prompt, no code written by hand.

Then inside a project:

Swap /model and re-run to compare against Fable 5.1, Kimi K3, or anything else you have access to. Full command reference: commandcode.ai/docs/slash-commands/design. More one-shot comparisons like this one live in CommandCodeAI/slash-design-showcase.