I let AI build a fully destructible city game in 47 hours

Imagine spinning up a blank Unity project, handing it to an AI agent, and coming back two days later to a fully playable game where you grow a hungry kaiju and level an entire city. That’s exactly what happened here: a 47-hour experiment in letting AI handle almost everything, from 3D assets and VFX to voiceovers and game logic.

The challenge: a fully destructible AI-built city

The goal was simple but brutal: ask an AI system to build an entire city that can be destroyed piece by piece. Every building should crumble, cars should fly, VFX should go wild, and the player should control a growing kaiju that can eventually wipe everything out.

To make this work, the creator prepared a clean setup: a gaming laptop, Unity, Blender, a fresh project folder, and a carefully engineered prompt packed with references, concepts, and tool instructions. The AI wasn’t just asked to “make a game” — it was guided step by step on how to use specific APIs and workflows.

Why prompt preparation matters so much

A key lesson from earlier projects was that references alone aren’t enough. If you only show concept art or screenshots, the AI might pick the wrong tools or produce assets that don’t fit together.

This time, the prompt didn’t just describe the vibe of the game; it also included detailed instructions like which APIs to use for what, how to structure characters, and how to handle technical details such as UVs and rigging.

The AI tool stack behind the game

Several AI tools and APIs worked together to build the game’s content and logic:

• Hunyuan 5.5 – the main model orchestrating a lot of the generation and decision-making, especially once heavier work started.
• Higgsfield – the primary asset generator, used heavily for 3D models, images, and various in-game content, backed by a large credit budget.
• Tripo (3.1 / 5.1) – used to generate 3D models, with the caveat that some versions are better for high-poly objects than for characters.
• Chopper API – focused on character creation, including splitting characters into parts, generating UVs, and making emissive maps.
• ElevenLabs – for voiceovers, giving the game a fitting narrator at a surprisingly low cost.
• Claude – used as the main reasoning engine and controller, with a high-token plan to keep the agent running long enough to build everything.

The AI agent also used Unity and Blender as its main DCC and engine tools, opening, editing, and wiring up assets into a working game.

Designing smarter prompts for 3D and characters

One of the most important prompt upgrades was a “special skill” description for character creation. Instead of just saying “make a monster,” the instructions told the AI exactly how to:

• Generate the kaiju in modular parts using Chopper API.
• Create proper UV maps so color textures could double as emissive maps.
• Increase the odds of correct rigging by steering away from the wrong 3D models or pipelines.

Without that guidance, the AI might have used an unsuitable 3D modeler (like a high-poly-focused Tripo variant) or produced unriggable meshes. By spelling out the workflow, the final kaiju model ended up rigged, animated, and functional in-game, even if its animations were a bit rough.

Budgeting the experiment: how much it actually cost

This wasn’t a free experiment. The AI agent was given a serious budget to pull from multiple APIs:

• Roughly $500 total budget for Higgsfield and other tools.
• About $300 spent on Higgsfield assets alone.
• ~$20 on Tripo credits.
• ~$10 on Full AI API.
• ElevenLabs voiceovers cost around $5 for more than 400 jobs.

On the LLM side, the build used around 5.28 billion tokens, with 97% served from cache, leading to an estimated API cost of about $2.5K if you priced it purely as token usage. In practice, discounts and top-up structures can lower that, especially on “ultra” plans.

What the AI actually built in 47 hours

The AI ran for about 47 hours in total, with a hiccup in the middle when Unity hit an out-of-memory error and had to be restarted manually. Ignoring that pause, the effective build time was closer to 38 hours.

In that time, the agent produced a surprising amount of content:

• A complete, explorable, and destructible city with multiple zones.
• Around 300+ 3D models generated via Higgsfield and other tools.
• Roughly 367+ image jobs for textures, UI, billboards, and more.
• 2,000+ images in total behind the scenes, including animation sequences and environment details.
• Custom billboard videos, VFX elements, and a variety of in-world props.
• Voiceover narration and in-game text using ElevenLabs and LLMs.

All of this was logged and documented as the agent worked, including before/after screenshots where it responded to feedback like “don’t use cheap orange blinking lights” and then replaced them with better color choices.

The core gameplay: raising a kaiju Tamagotchi

The game isn’t just mindless destruction. There’s a playful twist: you’re essentially raising a baby kaiju, like a monstrous Tamagotchi, as it grows from tiny beach-dweller to city-crushing colossus.

At the start, you spawn as a small creature on a beach, hungry and weak. You can:

• Eat small creatures like crabs and pigeons.
• Snatch silly items like a rat’s pizza.
• Perform small jumps and basic attacks.

As you eat and gain weight, your kaiju grows, unlocking new areas and more destructive power. Early on, you’re even blocked from leaving zones (like the street market) until you reach a certain size. Under the hood, there are also debug “cheat codes” to instantly jump to later stages for testing.

From small monster to city-level threat

Once the kaiju grows, the destruction fantasy really kicks in. Later stages let you:

• Eat cars and fling vehicles around with physics.
• Smash buildings into chunks that stay broken for the rest of the session.
• Trigger more intense VFX as your size and power increase.

The city includes recognizable elements like a cybertruck-style vehicle (complete with an in-world joke calling it a “stainless steel wedge truck”), buses with zero passengers for safe destruction, and a neon square area filled with billboards and ads.

Everything you destroy stays destroyed. When you move from one district to another and back again, you’ll see the persistent damage you left behind, making the city feel more like a real simulation instead of a reset-on-exit scene.

Neon squares, billboards, and a living city

One of the more impressive parts of the build is how alive the city feels, considering it was assembled by an AI agent. There are:

• Neon squares with huge screens showing AI-generated ads and breaking news.
• Sneaker ads, fictional brands, and ambient visuals on billboards.
• A park inspired by New York’s large green spaces, tucked near the main square.
• Helicopters and light military responses spawning as you grow more dangerous.

All of these elements were generated from the original instructions, not handcrafted. The AI created the visuals, wired them into the world, and even added small touches like helicopters firing at you as you approach key objectives.

Destruction, physics, and performance

The entire experiment was designed to test how well AI can handle complex, physics-heavy gameplay. The results are rough around the edges but surprisingly stable:

• Cars and buses fly convincingly when hit, with basic but satisfying physics.
• Buildings can crumble in large chunks once you’re big enough.
• Some structures only become destructible after you reach higher stages, emphasizing progression.

There are imperfections: some fire VFX don’t actually damage objects, certain buildings break into a few oversized pieces, and not every structure is perfectly smooth to destroy. But the big surprise is stability — the game ran for more than 30 minutes of playtesting without a single crash or game-breaking bug.

The final mission: destroy the reactor

The game isn’t just a sandbox; it has goals and an ending. As you grow, you’re guided toward a final objective: a reactor across the water.

To get there, you must:

• Grow large enough to cross bridges and barriers.
• Survive light military harassment from helicopters.
• Navigate through multiple districts, including the neon square and park.

Once you reach the reactor and destroy it, the game ends with a summary of your performance. You see your stats, an overall grade (like an A rank), and which achievements you unlocked. There are more achievements than you can easily get in a single rushed run, encouraging replay or more careful play.

How close is this to a “real” game?

From a traditional game dev perspective, the result is still rough. Animations can feel stiff, some NPCs look flat, and the kaiju’s attack animations don’t always line up perfectly with what they’re supposed to hit.

But the big picture is what matters here:

• The game was built in a single, mostly uninterrupted run by an AI agent.
• There was no long cycle of manual bug-fixing or iteration.
• It includes a full gameplay loop, progression, achievements, and an ending.
• It’s stable enough to play from start to finish without crashes.

A year ago, AI-generated games often required heavy human intervention just to be playable. Here, the agent combined multiple tools, generated thousands of assets, wired up physics and logic, and shipped something that feels like a real prototype. It’s still a long way from a polished AAA release, but it’s a massive leap in what small teams — or even solo developers — can do with AI agents.

If you’re curious how far this kind of automation can go on the systems side, it pairs interestingly with experiments like building a universal AI agent that can actually use your PC to control tools directly.

Lessons for AI-assisted game development

This experiment highlights a few practical takeaways for anyone using AI to build games:

• Be explicit about tools. Don’t just say “make a character” — specify which API to use, how to structure meshes, and how to handle UVs and rigging.
• Budget realistically. High-quality 3D, VFX, and voiceover pipelines can be surprisingly affordable per asset, but total costs add up over long runs.
• Expect rough edges. Animations, fine-tuned physics, and polish still benefit heavily from human oversight.
• Use AI as a force multiplier. Let agents handle bulk asset generation and wiring so humans can focus on design, feel, and refinement.

For developers, this kind of workflow points toward a near future where AI can assemble working prototypes in days, giving you something to play, test, and iterate on instead of spending weeks just getting a greybox running.

Where AI-built games go next

This kaiju city experiment is just one example of what AI agents can already do with the right prompts and tool access. There are parallel projects exploring other genres, like horror games built with GPT-based agents, and more complex AI systems that learn to play or optimize games on their own — similar in spirit to experiments like building a game-playing AI from scratch.

As models get better at reasoning, tools like Higgsfield and Chopper expand their APIs, and engines like Unity and Unreal become more AI-aware, we’re likely to see more games where the bulk of the first prototype is assembled by an agent. Human developers won’t disappear — but they’ll spend more time directing, curating, and polishing, and less time doing repetitive setup work.

For now, the takeaway is simple: with the right stack and a well-structured prompt, an AI can already build a chaotic, surprisingly fun, fully destructible city for your inner kaiju to destroy — in under two days.