You play Ricky, a raccoon burglar with a flashlight. Shadow Heist is a real-time stealth game for iPhone and Android: no turns, no grid, no combat. The flashlight lights the way, and that light is exactly what every guard in the building is watching for.

Download on the App Store / Get it on the Play Store

Every mission asks for two things: claim the objects the Boss has named, and steal a quota of food. When both are done, the exit opens.

An office at night washed in green: the jammer's sonar wave rolling through the room and shutting down the cameras, the raccoon stealing from a desk in the middle of it

The campaign runs to sixty missions in six chapters, each one its own kind of building with its own cast: a home, a shop, an office, the docks, a restaurant and a factory.

Ricky carries six tools: a key, a coin, a glue trap, a blowgun, a jammer and a cloak. None of them make you safe. They buy you a window.

Each tool is introduced with its own short film, then a small training level that can only be beaten with it. By the time the tool matters in a real mission, you have already used it once.

Twelve years of product design teach you a lot, but not a difficulty curve, a guard’s patrol or how to light a scene at night. That was the point. I wanted to find out whether one designer, working alone, could use AI as a production team rather than as an assistant, and finish a real 3D game instead of a prototype.

Shadow Heist is two programs, and the player never sees the seam. Flutter is the app: everything around a mission, from the home screen to the shop and the saves. Unity is the game: the mission itself, in 3D. The game runs inside the app.

The split follows the work. An app needs screens, a store, translations and an economy, which is what Flutter does well. A stealth game needs real-time 3D, lighting and navigation, which is what a game engine is for. Every rule that touches money or progress lives on the app side, so the game never decides what a player owns.

The choice was made on evidence, not taste. Before committing, I tried drawing the 3D directly in Flutter, and it was far too slow on Android. Unity, tested on real phones, held 60 frames per second and never crashed. That settled it.

The look is stylised low-poly, always at night. The buildings are furnished from professional 3D asset kits, and the flashlight is the only light that moves. The whole game is about that one light, so the scene is built around it.

Colour carries the rules: yellow for furniture holding food, green for hiding places, red for locked doors and for what a guard can see. A player reads the room at a glance.

The guards change with each chapter. Each one was generated as a 3D model with Tripo AI, then rigged and animated in Unity. They all share one set of animations, so adding a new guard costs almost nothing.

This is the part that made the game possible to finish. Sixty missions are too many to design by opening a 3D editor and dragging furniture around. So I built a level planner: a tool that draws every level as an architect’s plan seen from above, with everything the player will face on it, and what is wrong pinned to the map.

A level is just two files, the building and the heist, and the planner draws from the same files the game builds from. A plan that passes review goes straight into the game, where Unity builds the 3D scene automatically.

What the planner checks is where my design judgement lives. Everything a player needs must be reachable, by the raccoon and by the guards alike. All the food must be reachable, because three stars take all of it. Every locked door must protect something worth opening it for.

Difficulty is budgeted, not guessed. Each threat has a weight, and each chapter has a budget. Every chapter introduces one new threat and opens a little easier than the last one closed. Even the time limit is calculated from the shortest route through everything a three-star run needs.

The planner's full sheet for an office finale: open-plan offices arranged in a ring around a locked core, two guards, camera sweeps drawn as orange wedges, a laser across a doorway, and a side panel listing the house size, guards, objects, food goal, star thresholds and the issues found

Halfway through, I played chapters two and three and they were no fun: too many guards, patrols too long to read, threats stacked on the same spot. The cause was one of my own rules. Every object had to be guarded, and the easy way to satisfy that was to send a patrol through a camera’s view. So the planner learned two new rules: threats spread out so each one can be handled on its own, and patrols short enough that a player can follow two guards at once. A judgement call became a check that every level after it has to pass.

That is how the content scaled. The planner and all 66 levels, sixty missions plus six drills, came together in eight days. The later chapters were drafted by several AI agents working at the same time, each from a written brief for its chapter, then reviewed on the plan and corrected by hand.

The story is told in twelve short films: an intro, one for each new chapter and one for each tool. They give the game a story, and they introduce each new place and each new tool before you play with it.

Working alone means there is no design review, so the system had to enforce itself. Every screen is built from one kit.

Colour carries meaning, and money is where it matters most. Gold is a price in coins. Green is a price in real money. They never swap, so a player always knows what kind of price they are looking at before reading it. The HUD inside the game uses the same colours as the app around it.

A few principles are written down and tested rather than just intended. The defeat screen encourages and never says lost or failed. And every screen is rendered automatically in all seven languages, so a German label that overflows gets caught before a player sees it.

Claude Code wrote the code for the app, the game and the planner. My job was the system around it, so that the work held up from one session to the next.

Rules that remember. Every project starts each session by reading its own rulebook, and those rulebooks read like a log of design decisions: each warning records a trap already hit and why things are now the way they are.

Nothing depends on a click. Every scene, every level and every build is produced by a command, never by a setting someone clicked in an editor. That is what lets an AI work on a 3D game at all.

Checks that prove it works. Automated runs play every level and prove it can be won. When a check fails, the level gets fixed, never the check.

Tests that pin the product. A bundle must cost less than its parts. Every language fits on a small phone. These are product decisions, and the tests stop them drifting.

Two thumbs on glass. A two-stick game lives or dies on touch, and two thumbs is exactly where it broke. Both platforms got it wrong in their own way, and both were traced on real phones and fixed at the source.

The weight of a 3D game. Six chapters of furnished buildings are heavy. Only the first chapter ships with the app; the rest arrive from the stores when they are needed.

Then there is the part nobody warns a designer about: signing, age ratings, privacy and store listings in seven languages. None of it is design work, and all of it stands between you and release.

The store screenshots and videos are not mock-ups. A capture tool runs inside the real game and stages each shot, so every image is the game as a player will see it. The trailer at the top of this page pairs each film with the same moment in the game.

When the game changes, the store art is captured again rather than redrawn. The key art is the one piece made separately, generated with an image model.

Shipping was the start of the campaign, not the end of it. More chapters, more tools and more to steal are coming, and the pipelines are why that is a schedule rather than a wish. A new level is two files the planner already knows how to check, and a new guard already knows how to move. Most of what comes next is design, not engineering.

If you have a game, a product, or an interactive experience you want built this way, with an AI pipeline that produces shippable work instead of demos, reach out.