跪拜 Guibai
← All articles
Unity3D · AIGC · Game Development

Building a Walking 3D Little Prince with AI: 16 Days, 115 Asset Bundles, and One Inverted-Controls Bug

By Behaviour ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

For a Western developer evaluating AI-assisted game or 3D pipeline work, this is a concrete proof that a lone developer can assemble a multi-level walkable web game in just over two weeks, and the deep-dive of the actual build artifacts shows exactly which architectural choices made it feasible.

Summary

X user @Saccc_c shipped littleprince.dev, a 3D narrative game based on The Little Prince, claiming a 16-day build using Claude's Opus 5.5 for logic, Tripo for base 3D models, and Blender for polish. The game went viral on Hacker News and Chinese tech media, but the official site itself carries the most useful intelligence: it's a Unity 6 WebGPU build, and the embedded manifest lists 115 Addressables asset bundles totaling 2013.4 MB uncompressed.

The bundle structure reveals the game's architecture: one Addressables group per planet, with shared assets resident and high-res layers loaded on demand, which is what makes the scenes walkable instead of a slideshow. The pipeline the author describes is a clean, repeatable loop: split the book into independent level slices, generate base models with Tripo, refine in Blender and export glTF, assemble in Unity with per-planet Addressables groups, and drive script and scene wiring through Claude Code with a CLAUDE.md convention file.

The article also documents a concrete AI-workflow bug: a player reported inverted W/S and A/D controls after completing the watering quest, and neither the player nor the author could reproduce the trigger, a classic state-sequence-dependent failure. The missing open-source repo and the outstanding promise of a detailed walkthrough remain the boundary of what's verifiable.

Takeaways
— A solo developer built a 3D narrative game of The Little Prince in 16 days using Opus 5.5 for logic, Tripo for base 3D models, and Blender for refinement.
— The game's official site is a Unity 6 build using the WebGPU backend, requiring Chrome or Edge and excluding mobile and tablet.
— The site's manifest lists 115 Addressables asset bundles totaling 2013.4 MB uncompressed; the largest single bundle is the geographer's geo_scenes_all at 163.2 MB.
— The game is structured as one Addressables group per planet, with shared assets resident and high-res layers loaded on demand, enabling walkable scenes.
— The recommended pipeline is: split the story into independent levels, generate base models with Tripo, refine in Blender and export glTF 2.0, assemble in Unity with per-planet groups, and drive logic through Claude Code.
— The author recommends writing detailed CLAUDE.md conventions via /init so the model doesn't re-invent dialogue systems or asset grouping each session.
— AI task granularity should be small and verifiable, e.g., adding a trigger with specific distances and fallback behavior, not "make a game"
— One known bug reverses W/S and A/D controls after the player completes the watering task, and the trigger condition remains unidentified, pointing to state-sequence-dependent failures in AI-generated code.
— The acceptance checklist per level is: walk in, trigger the story, walk out, loading doesn't time out, and controls work.
— The game's eight levels are split into chapters corresponding to book planets, with two levels (theater, bar) added by the author that have no direct book counterpart.
— As of the writing date, the promised open-source release and the detailed production walkthrough have not yet been published.
— The site offers eight language options, including French, the book's original language.
Conclusions

Reading the site's HTML and asset manifest reveals more about the project's architecture and its AI workflow than the author's own narrative does, since the bundle prefixes and sizes expose the level-splitting and on-demand loading strategy directly.

The biggest asset bundle belongs to the geographer, a character with almost no plot; this illustrates that AI-assisted asset generation shifts the cost toward whatever textures or scenes the source text describes, not what the story actually needs.

The inverted-controls bug, which neither author nor player could reproduce, is a generalizable warning about AI-generated game code: long-horizon edits that depend on state sequences are the least testable and most likely to break invisibly.

The author's decision to pin conventions in CLAUDE.md before starting iterative edits is the most transferable and likely highest-ROI step in the entire pipeline.

The 16-day claim and the open-source promise remain unverified; what's checkable is the live site's build output and the reported tool division, so treating the rest as marketing is reasonable.

Concepts & terms
Addressables (Unity)
Unity's asset management system that allows developers to assign assets to groups and load them on demand, in this case one group per planet to keep the initial download small and pull in high-res content only when needed.
WebGPU backend (Unity)
Unity 6's rendering backend for the web that uses the WebGPU API directly, bypassing the JavaScript bridge that WebGL requires, reducing overhead on large scenes at the cost of narrower browser support.
MCP (Model Context Protocol)
A standard that lets an AI assistant like Claude talk to external tools; in this pipeline a Unity MCP bridge allows the model to directly create GameObjects and run Play Mode inside the editor.
Source: juejin.cn ↗ Google Translate ↗ Backup ↗