You could be the first human ever to play the game below.

An AI agent built it from the plan in this guide. Bots played its twin, built in the Godot engine, 4,000 times. No person has played either one, me included.

So try it. A round takes three minutes at most. Then I’ll show you how to make your own, including what broke when we ran these prompts for real.

Tell me how it went in the comments. Give me your twig count and your device. And was it fun? Bots can’t answer that one.

Can AI really make a whole game?

No, not by itself.

In GameDevBench, an independent test of 333 Godot tasks, the best agent solved 53.8%, and Roblox’s own benchmark topped out at 51.7%. Newer models scored 15 out of 15 on tiny tasks in a test by Flockbay, which sells on Godot, but nobody has measured a beginner using one over weeks. So plan on your first attempt failing about as often as it works.

We ran our Godot prompts exactly as written, and they produced this:

• The player walked off the screen, because no prompt set the window size.
• Every restart was an instant loss, because the fire’s health survived the restart.
• The game could become unwinnable, because twigs lost in the rain never came back.
• Standing on a twig did nothing until you walked off and back.

None of those showed an error at first. One broken script even finished as if it had succeeded. We saw some of these traps coming and ran the literal prompts anyway, to see what happened. The prompts in this guide are the fixed versions.

So what are your odds?

Nobody knows. I looked for a beginner finish rate and couldn’t find one. You’ll see numbers like 88% floating around, but the ones we could trace don’t measure finished games.

Real people are shipping though. An accountant put a story game on Google Play, a music producer put a demo on itch.io, and someone with “ZERO experience writing code” built a Steam demo. All of that is self-reported, and most of these games have almost no players yet.

What do you need to know before you start?

Learn these seven words now and the AI’s answers stop sounding like noise.

If you search “game AI”, you’ll find enemy pathfinding tutorials, which are a different topic from using AI to build the game.

Which route should you pick?

Answer four questions. Your device decides more than you’d expect.

The table has the same picks, plus what each route costs you in freedom. These picks are my judgment from docs and reports, and I haven’t tested them with real beginners yet.

Godot isn’t the easy option people say it is. It’s free and light, and what you make is yours. But when the AI fails, you’re reading code.

Be careful with prompt-to-game platforms. They’re fun, but test the exit first. Rosebud’s terms say it “shall own” prompt output. Commercial rights start at $30 a month, and code download at $50. Gambo shut down in May 2026 and its domain is parked. If you can’t export on day one, treat it as a toy. Comparing tools? See our AI prototyping tools guide.

Claude or Codex?

I couldn’t find a current test where both built the same game. On older models, the one independent benchmark put Gemini and GPT above Claude for Godot. Roblox’s leaderboard puts Claude’s top model first, but that model costs extra on the $20 plan.

So try Codex’s free tier first, because it exists and Claude Code’s doesn’t. Pay about $20 a month only if it stalls. One plan is enough. This research ran on Claude, so I’m not a neutral judge here. For more on each, see what works and breaks in Claude Code and using ChatGPT for game development.

What does it cost?

It costs little money and a lot of time. Prices are from vendor pages, checked November 1, 2026.

The real totals I found are all self-reported. One first-timer spent $45 including the Google Play fee. A non-technical writer spent about $106 and 40 hours on one playable level.

That first-timer also reported that “building took 3 days and fixing took 14.” Budget your time like that.

No credit card? GDevelop Free plus a free itch.io game should work, though I haven’t confirmed the sign-up flow. Google Play won’t take a prepaid card. Our free AI tools list has more options.

How do you set up an undo before you build?

Do this first, because AI agents break things that worked. One beginner says breaking something with no way back “can happen often when you vibe code”, meaning when you build by prompting without reading the code.

1. Make one folder for this game. Keep passwords, API keys and personal files out of it.
2. Save a checkpoint. On Godot or web, install GitHub Desktop and commit (save a checkpoint) after every feature that works. On GDevelop’s free plan there’s no version history, so copy the project to a dated folder.
3. Break it on purpose. Delete something, then go back. If you can recover in five minutes, you’ve learned the most useful skill in this guide.
4. Put a blank game online on day one. Use gd.games or an itch.io Draft page. That way you meet publishing problems early.

Copeland’s free GitHub Desktop walkthrough teaches this with no terminal, and it warns you that discard can’t be undone.

Is it safe to let an AI agent run on your computer?

Mostly, if you set it up right. Claude Code starts in auto mode, where a classifier approves actions for you. On native Windows it runs commands without a sandbox, the wall that keeps a program inside one area of your computer. Codex has a native Windows sandbox, and that’s a point in its favor.

• Start the agent inside the game folder, never your home folder.
• Commit before every request.
• Never use modes that skip permission checks, however many tutorials tell you to.
• Decline any download, any sudo (admin) command, and any delete outside the folder.
• Don’t let it read random README files from asset packs. Text in them can give it instructions.

We learned why the hard way. A Godot --import command during our test overwrote the real editor settings, and there was no backup. Some Godot commands change settings for your whole computer.

What should your first game be?

Smaller than you want. Aim for one screen and under three minutes.

Some people do ship big first projects with AI. A person who has never written code reports a multiplayer pirate game in a month, still in beta. But most failures never post, so you mostly see survivors. A vibe-coded metroidvania is one that did. It died at about 40 hours once its systems started tangling.

Tiny is my judgment, and I can’t prove it. But it gives you a finish, and the finish teaches you what a second game needs. Our game MVP guide goes deeper on starting small.

Avoid Sokoban and match-3 as “easy” starters. In Al Sweigart’s test, one model handled Asteroids and Tetris but failed Sokoban and Bejeweled. That’s one test of one model, but it runs against what you’d guess.

Why won’t AI remake your favorite game?

Because of a new rule, and because it was a bad plan anyway. Anthropic confirmed Claude Code on Opus 5.5 now steers away from “a recreation of a specific existing game, even if it is renamed or called original.” I found no equivalent rule in other tools. But switching tools doesn’t change your risk.

itch.io prohibits projects that “mimic the look, feel, or functionality of another creator’s work without permission.” Nintendo has taken down free fan projects for years, including a fan-game tool. Game ideas aren’t protected, but the specific way a game expresses them is.

So don’t reword the prompt. Change the rules, write them down, then ask the AI to build your rules. A monster-collecting game is fine. Pokémon isn’t.

What’s the game we’ll build?

Dry Kindling, the game at the top of this page. You tend the last campfire in a rainy forest. The theme is familiar, and Campfire has a similar loop. Our rule mix is our own, as far as a quick search shows.

That “won’t have” row is the most useful line in the doc. Write yours first, then point to it whenever the AI wants to add more.

How do you talk to AI so it works?

Tell it what it can’t see, and give it a way to check its work. Anthropic’s guidance comes down to that, and the same idea shows up in OpenAI’s. Seven habits do most of the work:

1. Name the engine and version. “Godot 4.7.2”, every session. It mixes up old versions otherwise.
2. Ask for one thing. One mechanic per request.
3. Ask for a plan first. “List the nodes and files, then wait for my OK.”
4. Say what not to touch. “Change nothing else.”
5. Ask how to test it. “Tell me how to check this in 30 seconds.”
6. Paste exact errors, with your steps. Say what you did and what you expected.
7. Restart after two failed fixes. A third correction adds to a conversation already full of failed attempts.

Write in your own language if that’s easier. Use its normal writing system, and keep error text exact.

You can also write down what it forgets. The accountant from earlier keeps “One main document with every decision and change. The AI forgets, the document doesn’t.” More prompts are in our prompt library.

How do you build it, step by step?

Tick off these seven milestones as you go, and your progress saves in this browser. Hours are my estimate for a first-timer, with no allowance for bad days.

The browser prompts are the tested ones. A fresh AI agent, running on Claude, got them one at a time in an empty folder, and we tested the finished build in Chrome with scripted key presses. An earlier run exposed gaps, such as no instructions for new players, so we fixed the wording and ran it again from scratch. The zip and the itch.io upload weren’t part of that test.

The Godot prompts carry fixes that passed when an agent ran them, but the final wording hasn’t been re-run from scratch. The GDevelop prompts have never been run. No beginner has tried any of them, so you may be the one finding the next bug. Tell me.

Create index.html in this folder as one file: plain HTML, CSS and JavaScript, no libraries and no build step. Draw a 1280x720 canvas that scales to fit the browser window and keeps its shape. Show a dark background and a small title, 'Dry Kindling', at the top. Write AGENTS.md saying: one file, no libraries, every gameplay number lives in a settings object at the top. Save the design document below as GDD.md: [PASTE]. Tell me how to open the game, and how to zip it for itch.io. Say which steps you could not verify.

I am new. Before I build anything, explain in 5 short bullets what a scene, an object and an event are in my empty project. Change nothing.

Godot 4.7.2 Standard, GDScript, Compatibility renderer, web target, no C#. If no project exists, create one. Set the viewport to 1280x720, stretch mode canvas_items, aspect keep. Create one scene with a dark background and a Label reading 'Dry Kindling'. Set it as the main scene. Write AGENTS.md recording these facts, and save the design document below as GDD.md: [PASTE]. Check whether 4.7.2 export templates are installed. Give me the exact clicks to install them and to export for web. Say which steps you could not verify.

Add a Keeper, a small colored square that starts to the left of the screen center. Arrow keys and WASD move it in 8 directions at a speed from settings, using delta time, and diagonals must not be faster. Keep the whole square on screen at 1280x720. Stop the arrow keys from scrolling the page, and release all held keys if the window loses focus. List what you will add, wait for my OK, then build. Change nothing else.

Add object Keeper using a placeholder sprite. Use top-down movement so arrow keys and WASD move it in 8 directions, and keep it inside the 1280x720 screen. Change nothing else.

Add a Keeper scene using CharacterBody2D in floating motion mode, with a collision shape and a visible colored Polygon2D. Use input actions for arrow keys and WASD. Speed lives in settings.gd. Keep the whole body on screen at 1280x720. List the nodes, wait for my OK, then build.

Add a twig, a small brown bar, at a random spot, staying out of the top 100 pixels. Each frame, check whether the Keeper overlaps it, so a change of state while touching still counts. If the Keeper isn't carrying: remove the twig, set carrying to true, drop speed to 70%, and draw a small twig above the Keeper. Tell me how it detects the touch.

Add object Twig placed at a random spot. Add boolean variable Carrying on Keeper. When Keeper touches Twig and Carrying is false: delete Twig, set Carrying true, reduce speed to 70%. Show me the events you made and explain each.

Add a Twig scene with Area2D at a random spot. Each physics frame, check get_overlapping_bodies(), not only body_entered, so a change of state while touching still counts. If the Keeper is not carrying: free the twig, set carrying true, use carry speed from settings, show a small colored Polygon2D above the Keeper (no images exist yet). Tell me how it detects the touch.

Add a fire at the center of the screen, plus fireHealth (start 60, max 100) and twigs delivered. When the Keeper touches the fire while carrying: add 10 to fireHealth up to 100, add 1 to twigs delivered, stop carrying, restore speed, and create a new twig at a random spot. Start with 3 twigs on screen, and never spawn one on top of the fire. Show fireHealth and twigs delivered as plain text.

Add object Fire at screen center, scene variables FireHealth (start 60, max 100) and Twigs. When Keeper touches Fire and Carrying is true: add 10 to FireHealth up to 100, add 1 to Twigs, set Carrying false, restore speed, and create a new Twig. Keep 3 twigs on screen. Show FireHealth and Twigs as debug text.

Add a Fire Area2D at the center and a GameState script with fire_health (start 60, max 100) and twigs. When the Keeper touches the Fire while carrying: add 10 up to 100, add 1 to twigs, stop carrying, restore speed, create a new twig at a random spot. Start with 3 twigs. Show fire_health and twigs as debug text. Add a plain test, a script extending SceneTree, for the health cap. Use load(), not preload. It must quit with a non-zero code on failure and have a watchdog. Give me the exact command to run it.

The fire loses 1.2 health per second using delta time. Add a 180-second countdown, a fire bar labeled 'Fire' and a result screen: 'Dawn' with twigs delivered, or 'The fire went out' with twigs and time survived. Enter restarts. Before the first round, show a start screen with these rules: move with arrow keys or WASD, carry twigs to the fire, keep the fire alive for 3 minutes. The round starts on Enter or a click. Every value must reset on restart. Decay must not depend on framerate. Explain delta in one sentence.

Reduce FireHealth by 1.2 per second using TimeDelta. Add a 180-second countdown. If FireHealth reaches 0, go to a Lose scene; at 0 seconds go to a Win scene. Each shows Twigs and restarts on Enter. Add a fire health bar and a timer as text.

Fire loses 1.2 per second using delta. Add a 180-second timer, a HUD with a bar and text, and a result screen: 'Dawn' with twigs delivered, or 'The fire went out' with twigs and time survived. Add Enter as an input action to restart. Every value must reset on restart, including anything in an autoload. Decay must not depend on framerate. Explain delta in one sentence.

Plan only. I want rain columns: pick one of 5 screen columns; show a warning stripe for 1.5 s; then pour for 1.0 s; if the Keeper is inside while carrying, the twig is lost; if the Fire is in the column, Fire loses 8. First rain at 6 s, then one every 6 s. The fire loses 8 once per pour. The Keeper is inside if its center is in the column. A lost twig is replaced at a random spot, and the Keeper's speed is restored, so the map can never run out of twigs. Rain must reset on restart. Add one line about rain to the start screen. List the state, timers and order of events. Wait for approval.

Plan only. I want rain columns: pick one of 5 screen columns; show a warning stripe for 1.5 s; then pour for 1.0 s; if the Keeper is inside while carrying, the twig is lost; if the Fire is in the column, Fire loses 8. First rain at 6 s. The fire loses 8 once per pour. A lost twig is replaced at a random spot, so the map can never run out of twigs. List objects, variables, timers and order of events. Wait for approval.

Plan only. I want rain columns: pick one of 5 screen columns; show a warning stripe for 1.5 s; then pour for 1.0 s; if the Keeper is inside while carrying, the twig is lost; if the Fire is in the column, Fire loses 8. First rain at 6 s. The fire loses 8 once per pour. The Keeper is inside if its center is in the column. A lost twig is replaced at a random spot, so the map can never run out of twigs. List nodes, scripts, timers and order of events. Wait for approval.

Move every gameplay number to the settings object, with comments. Rain interval goes from 6 to 2.5 s and decay from 1.2 to 2.4 across 180 s, by elapsed time. Replace the plain debug text with 'Twigs: N', and keep the fire bar and a countdown on screen.

Rain interval should go from 6 s to 2.5 s across 180 s, and decay from 1.2 to 2.4. Put the start and end numbers in clearly named variables so I can edit them by hand.

Move every gameplay number to settings.gd as named constants with comments. Rain interval goes from 6 to 2.5 s and decay from 1.2 to 2.4 across 180 s, by elapsed time. Remove or hide debug text outside debug builds.

You now have roughly the game at the top of this page, with no sound. Don’t polish yet. The next two sections will save you more time than any feature.

How do you know it works?

You play it. Don’t take the AI’s word for it, because “Claude stops when the work looks done”, in Anthropic’s own words. If it has nothing to run, “looks done” is all it has.

That’s why it keeps saying it’s fixed. So never accept the word “fixed”. Ask what it ran, then replay the steps yourself. In one video tutorial, an AI’s test passes on screen while the feature is broken.

Use a test card

Roblox’s guide tests each round against named parts of the game, like Hazards and Win zone. Copy that with this card for any feature:

1. Do the action once, then try it again immediately.
2. Try everything it touches. Add a twig, then check the score and the fire.
3. Restart five times. That’s where our fire-health bug hid.
4. Close it and reopen it.
5. Run the exported build as well as the preview.
6. Watch one person play without helping.

If you don’t code, ask the AI for a cheat menu that jumps to any moment, so you can test the end without playing for three minutes. And ask it to write tests for rules like “health never goes over 100”, then break the rule on purpose to prove the test can fail. GDevelop’s AI can write and run gameplay tests, though that feature is experimental.

Is the code any good?

You can’t fully tell, and for a tiny game you don’t need to. The warning sign is each fix taking longer than the last. These checks may help, but we haven’t proven them:

• Open a fresh session. Can it make a small change without breaking anything?
• Ask it to explain the layout. Does that match your design doc?
• Ask a second AI to list only problems a player would notice.

Fix those and ignore style complaints. A reviewer asked to find problems will always find some.

What do you do when it breaks?

First work out what happened. Either the game runs but does the wrong thing, a script crashed, or it’s stuck waiting. Then read the message. Most guides say to paste it back to the AI, and that does work. But try reading it first.

These are real errors from our test build. Guess before you open each one.

The "onready" keyword was removed in Godot 4. Use the "@onready" annotation instead.

Invalid assignment of property or key 'visiblee' with value of type 'bool' on a base object of type 'Polygon2D'.

ERROR: Can't change this state while flushing queries. Use call_deferred() or set_deferred() to change monitoring state instead.

SCRIPT ERROR: Compile Error: Identifier not found: GameState

No export template found at the expected path:

GDQuest’s error guide teaches a proper five-step method, and it warns that the highlighted line may not be where the cause lives. It assumes you know basic GDScript.

What if there’s no error at all?

Those were our worst bugs. For silent ones, say what you did and what you expected, and write “no error appeared”. Then ask for temporary print lines tagged TEMP_DEBUG. They write to the log so you can see inside the game, and the tag makes them easy to remove.

When should you stop asking the AI?

Where can you ask for help without getting flamed?

Some places dislike AI projects. One r/godot post saying AI games “don’t belong” hit 1,918 points, with replies split. That’s one member’s view, and I couldn’t read the current subreddit rules.

The GDevelop forum and Godot forum have no AI rule in their FAQs. Write in your own words and say AI wrote the code. Paste the small part that’s failing and the error, so people can see you tried.

How hard should your game be?

Harder to judge than you think. We had bots play the Godot build 4,000 times, because that’s what you can do when nobody can play it. These skill levels are my assumptions.

In the Careful column, going from 1.50 to 1.65 takes wins from 81% to 44%, so no single setting suits everyone. Rain barely moved the numbers. A perfect bot ignoring rain still won 95%, so for skilled play the fire’s burn rate decides this game.

The game above and the prompts use the easiest row. The First-timer bot still loses at every setting, so you might too. If you do, tell me how far you got.

So keep your numbers in one settings file, change them by small steps, and test with more than three plays. Three plays can’t tell 1 in 3 from 1 in 2. And AI can’t tune this for you, because it doesn’t know how the game feels. “Juice It or Lose It” and “The Art of Screenshake” are the classic talks on making actions feel good, and I haven’t watched them yet.

Can you use AI art and music in your game?

Yes, but read your plan’s terms first. Free AI output is often not yours to sell. For a first game, use human-made packs. They’re free and they match.

Type a tool name below to check it. Terms change, so save a copy of them on the day you generate anything.

Use AI art when no pack has what you need. Lock the style before your second asset, and test three pieces in the engine. One builder reuses the same reference images and style text in every prompt. Our pixel art comparison, free AI art tools guide and AI music comparison go deeper.

Do you own it? The US Copyright Office says “prompts alone do not provide sufficient human control” to make you the author. So others may be able to reuse your raw AI sprites. Your edits, writing and arrangement are what you can protect. This isn’t legal advice, and that view isn’t binding law.

What goes in your credits?

Whatever your licenses require, and it’s little work. Godot needs its license text available, and a link in your credits is enough. Open Font License fonts can be bundled but not sold alone, so keep the license file. Skip fonts marked “free for personal use”. Keep one log with each file, source, license and date.

[Game title], made by [you].
Built with [Godot Engine | GDevelop | Phaser].
[Godot] License: godotengine.org/license. Third-party notices in COPYRIGHT.txt.
[GDevelop] GDevelop runtime, MIT license: [paste notice].
[Phaser] Phaser, Copyright (c) [year] Richard Davey, Phaser Studio Inc. MIT license: [paste notice].

Art: "[Pack]" by Kenney (kenney.nl), CC0.
Model "[name]" generated with Meshy (meshy.ai), free plan. Owned by Meshy, CC BY 4.0. Modified: [what you changed].
Sound: "[title]" by [author], [URL], CC BY 4.0. Modified: trimmed.
Font: [Name], Copyright [holder]. SIL Open Font License 1.1, see OFL.txt.

AI tools used: [tool] for [code | text | images]. Designed, tuned and tested by [you].

How do you publish your game?

Start with itch.io. It’s free, and a browser game avoids the scariest warning a beginner’s game can trigger.

1. Export for web. In Godot, install the export templates first, because both web templates are required. Leave the threads option off.
2. Zip it with index.html at the top level. itch.io allows up to 1,000 files and 500 MB. Filenames are case-sensitive.
3. Create the page as a Draft. Set kind to HTML and tick “played in browser”. Set viewport to 1280×720.
4. Fill in the AI Disclosure section. It covers code, graphics, sounds and text. Then say in your description what you designed and tuned.
5. Decide on Mobile Friendly. If you only support keyboards, leave it unticked.
6. Keep Click to play on, and add a Start button. Browsers block sound until a click or key press.
7. Test in a private window and a second browser. Then set it to Public.

Don’t go Public early. A public page “should be ready for everyone to see”, and it “can not be put on the top of the Most Recent page again.” You get one launch slot.

What about Steam, phones and Roblox?

Avoid desktop downloads for now. Unsigned Windows games show “Windows protected your PC” and must rebuild reputation with every update. Unsigned Mac exports get blocked by Gatekeeper. Web skips both.

Skip ads too, both kinds. In-game ads bring consent and privacy duties, and the accountant’s players said they hate forced ones. Paid ads may not pay back either. An engineer with 10 years’ experience spent about $300 on Meta ads and got about $60 back.

A free game on itch.io needs no forms. Your first sale brings a tax interview and payout setup. You don’t need a company. If real money arrives, ask a local accountant.

How do you get your first players?

I found no good data on this, so here’s my judgment. Enter one jam that allows AI and post one devlog per milestone. Then make one honest post with a playable link, and say you used AI before someone else does.

Will people hate your game because you used AI?

Some will. In one study of 508,192 Steam reviews, AI-tagged games were recommended 68.4% of the time, against 86.3% for procedural-generation games. Reviews that mentioned AI were positive 49.5% of the time. But that comparison isn’t against games in general, and low-effort games may drag the number down.

Attention is thin too. On itch.io, about 12% of AI-tagged games appear on its rated list, against about 19% of all games. On Steam, about 29% of AI-tagged games have 10 or more reviews. Neither number says why, or how many people gave up before publishing.

Replies to beginners can be brutal. “You didnt make anything here” is a real one. But one commenter pushed back that most people they talk to “couldn’t care less about how the sausage is made as long the sausage is good.”

You can’t control that, but you can disclose honestly and keep obvious AI out of your cover art. See our player reaction data and Steam disclosure guide.

And expect no money. In mid-December 2025 about 49% of that year’s Steam releases had under 10 reviews, though late-year games had little time. By January 2026, 2.99% had reached 1,000. Ignore any book that promises non-coders $50K a month without evidence.

What should you do after your first game?

Decide what you’re after, because it changes what you hand to the AI. In a 52-person experiment, developers learning with AI scored about 17% lower on a quiz than those without it. The researchers’ look at usage patterns hints that asking for concepts beats delegating, but those groups were tiny.

To learn properly, try Unity Essentials, which says no experience is needed, or GDQuest’s course. Make game two one step bigger. A 20-hour limit per project is a good rule from the 20 Games Challenge.

Going deeper with AI? See our vibe coding walkthrough, AI with Godot, Claude Code with Unity and Godot MCP servers.

Your next five minutes: play one round and post your twig count in the comments. Then write your “won’t have” list.

Quick answers to common questions

How was this guide tested, and what wasn’t?

Checked November 1, 2026. Prices and rules change, so check the linked pages.

• An AI agent built Dry Kindling in Godot 4.7.2 and for the browser, and ran tests and bots on it. The version above is the browser build, tested only by a bot and scripts.
• We didn’t run GDevelop, Roblox, Unity, web export from Godot, an itch.io upload or any paid plan. No human has played the game, and no beginner has followed this guide yet.
• Numbers come from the linked sources, many of them vendors or self-reports. Hours and route picks are my judgment.
• AI agents did the research and testing and drafted this page, running on Claude, which is why I’d have someone else check my Claude vs Codex call.
• This page has no affiliate links, and no tool paid for a mention.

If something here is wrong or out of date, say so in the comments and I’ll fix it.

The winner is an iOS developer called Leo. Leo ran two or three Claude Code sessions at once for about two weeks and describes the work as shifting “from coding to deciding.” Claude Code builds playable games, fastest in Godot or a browser engine, on a $20 to $200 plan. It can’t tell whether a game is fun, so that part of Claude Code game development stays with you.

Research-based guide, checked against Anthropic, Unity, Epic, Godot and Valve documentation and the developers’ own posts.

Can Claude Code make a complete game?

Yes, if the game is small. Claude Code has built a jam winner, a rebuilt 1992 online game, browser games with live players, and a port of a 1993 Amiga game. In each one, a person made the design calls and tuned the feel while Claude wrote most of the code.

• A Game About Capybaras Delivering Food: Three.js, Claude Code on Opus 4.7, Gold at Vibe Jam 2026. Leo tuned the feel and hand-built the map in an editor Claude wrote.
• Legends of Future Past: The engine source for Jon Radoff’s 1992 CompuServe game was lost. Claude Code rebuilt it in a weekend from old scripts and a 1998 game-master manual. It has 2,273 rooms and is open source.
• Babylonian Twins: Rabah Shihab moved 72,758 lines of 68000 assembly to Godot with Claude Code and Fable 5. The first draft took an evening. Tuning took weeks.
• Slimeshot: Phaser 3 and Fable 5, about 120 hours. Every sprite started as a grid of letters that a Claude-built tool turned into pixels.

Slimeshot and Babylonian Twins both have Steam pages, and both are still listed as coming soon. Most finished Claude Code games are short web games and small itch.io releases. Claude can carry a small game to release. A 40-hour RPG is still a team-sized job.

Which engine works best with Claude Code?

Claude Code works in a loop. It edits a file, runs something, reads what came back and decides what to do next. So the useful engine question is how much of your game Claude can read and run from a terminal.

Claude reads your project the way a new hire does on day one, through files. If a setting lives only in an editor window, Claude can’t see it unless a tool shows it.

Godot: the easiest engine for Claude

Godot saves scenes as .tscn text files and runs without a window. The command line gives Claude --headless to run the game, --check-only to parse a script for errors and --write-movie to record frames. Claude can run the game, read the errors and fix them without you clicking anything.

In a 2025 test by Classmethod, Claude Code finished a Godot Tetris in about 30 minutes and three prompts. The same game in Unity was still unfinished after two hours.

The weak spot is model knowledge. Claude sometimes slips into Godot 3 syntax. Pin your Godot version in CLAUDE.md and the problem mostly goes away.

Unity: text files, editor problems

You’ll read that Unity is hard for Claude because its scenes are binary. That’s wrong. Unity 6 saves assets in Force Text mode by default, so scenes and prefabs are YAML text.

Unity’s friction is in the editor. In the Classmethod test, Unity stalled on two things. Someone had to attach scripts to objects by hand, and a lighting setting rendered every block in monochrome.

Unity’s answer is the free Unity CLI, still in beta. It drives a running editor from the terminal, runs headless builds and runs your test suites. Unity says its direct commands are “faster and use fewer tokens than MCP.”

Unity has deprecated the MCP server inside its AI Assistant package. Guides that tell you to switch it on are out of date. Use the Unity CLI, or a third-party package like Unity-MCP, which the deprecation doesn’t affect.

Unreal: C++ yes, Blueprints barely

Unreal stores assets and Blueprints as binary .uasset files. Claude reads and writes C++ well. Visual scripting is where it struggles. An Unreal developer on r/ClaudeCode put it plainly: LLMs “still struggle with visual programming like Unreal blueprints.”

Unreal Engine 5.8 added an official Unreal MCP that lets Claude work inside the editor. Epic labels it experimental and says “many features are incomplete or missing.”

One developer’s test of an Unreal MCP spent three minutes and about 45,000 tokens making two red cubes. Our Unreal 5.8 MCP guide covers the setup.

Can Claude Code run your game and read the errors?

Yes. Some older guides say Claude can’t press play, but with a terminal it can launch the game and read the output.

Shihab’s Babylonian Twins port shows how. Claude Code built the game, launched it and read “what came back.” Then it added its own --probe and --screenshot flags.

Your engine decides which tools Claude gets:

• Godot: godot-mcp gives Claude run_project and get_debug_output.
• Unity: the Unity CLI runs your test suites.
• Web: Playwright screenshots the game in a browser.

What Claude can’t check is feel. Shihab played the build every night because feel was never checked by machine.

Kyle Kukshtel, a developer on the Steam strategy game Cantata, puts it bluntly: “structurally, LLMs are bad at reading games.” A log tells Claude the jump fired. It can’t tell Claude the jump feels floaty.

How to set up Claude Code for game development

1. Get Claude Pro or higher. The free plan doesn’t include Claude Code.
2. Open your project folder in a terminal, start claude and run /init. Claude scans the project and writes a first CLAUDE.md.
3. Edit CLAUDE.md so it names your exact engine version and the commands that run and test the game. Template below.
4. Connect the engine with the command in the table below.
5. Commit to git after every change that works. When Claude breaks something, you roll back in one command.

Here’s a lean CLAUDE.md for a Godot project. Every line gives Claude a fact or a command it would otherwise guess.

CLAUDE.md

# Game: [name]
Engine: Godot 4.7, GDScript 2.0. Never use Godot 3 syntax.
Run: godot --headless --path . --quit-after 600
Check a script: godot --headless --check-only --script res://[file].gd
Tests: [your test command]. Run them after every change.

Rules
- One mechanic per task. Show me the plan before you code.
- Ask before adding a plugin or dependency.
- Keep HANDOVER.md current: systems, decisions, known bugs.

You don’t need to trim MCP tools to fit a limit. Claude Code loads tool definitions only when it needs them, and Anthropic’s docs say it has no fixed per-server tool cap.

Claude Code Game Studios is the popular add-on. It gives Claude 49 agents and 74 skills that act like a small studio.

That structure costs tokens. One test on a tiny Godot game measured about $5 of usage with the template and about $0.15 without it. Use it for a real project. Skip it for a weekend prototype.

For more CLAUDE.md templates and copy-paste prompts, see our Claude game development guide.

What breaks when you build a game with Claude Code?

Balance is the one people warn about most. The developer of Cinderstead, a Stacklands-style game, wrote: “do not trust AI to balance stuff that requires actual gameplay.” Claude can tune a number to a target. It can’t play 50 runs and get bored.

Five habits from developers who finished a game

The developers who ship describe the same five habits. Most of them give Claude a way to check its own work.

1. Build the feel with plain shapes first. The developer of Hearthworks, a 3D survivors game, built movement, three spells and a boss with capsules and spheres. Art came only after the developer beat their own game.
2. Give every mechanic a test. One solo developer building a 2D RPG in Godot has more than 400 tests and runs them headless after each change. They catch Claude breaking code it touched three files away.
3. Let Claude check its own screenshots. Have it render the game to images and look before it shows you anything.
4. Keep a handover file. Without one, a new session forgets why code is the way it is and “fixes” it back.
5. Ask Claude to build tools. Leo calls Claude-built editors the “biggest multiplier” in the project. The LevelCraft developer shipped a smaller game, Ricochet, with its own level editor and website in 11 days of part-time work.

Claude does its best work when it can prove a change worked. “Make combat feel better” gives it nothing to check. “Dash covers four tiles in 0.2 seconds and can’t pass through walls” gives it a test. The more of your game you turn into checkable facts, the more of it Claude can build alone.

How much does Claude Code cost for game development?

Claude Code comes with Claude’s paid plans. Your Claude Code use and your chat use share the same limits.

Prices are from Claude’s pricing page. On Pro, the Fable 5 and 5.1 models run only on paid usage credits. Opus 5.5 and Sonnet 5.5 stay inside your plan. Type /usage in Claude Code to see where you stand.

What real projects spent:

• Capybara jam winner: Leo topped up $100 to move to the 20x plan. Leo’s total for every AI tool, art and music included, came to $119.90.
• Five small games in 50 days: a non-programmer spent $400 on AI and earned $4.99 in sales. Building a game got cheap. Selling one didn’t.
• Pro plan, daily use: one developer working on Opus 5.5 budgets 14% of the weekly limit per day and uses it all every week.

So Pro works if you plan your sessions. If you build for four or five hours a day, expect to hit the limit and move to Max.

Claude Code vs Codex vs Cursor for games

The Vibe Jam is the cleanest data point. Cursor sponsored it, and a Claude Code game won it. Unity’s official agent plugin lists Claude Code, Codex, Grok and Antigravity. Cursor isn’t on the list.

Developers who pay for both Claude Code and Codex describe a split. They build fast in Claude Code, then hand performance work to Codex. One wrote that Opus 5.5 “ships lots of working code that isn’t well-optimized.” Several $20-plan users say Claude gives them more usage per dollar. If frame pacing matters in your game, budget a cleanup pass whichever tool you pick.

Do you have to disclose AI when you sell your game?

Code written with Claude Code is the easy case on every store. AI-made art, audio or text is where the rules start.

Valve’s page says tools that make development more efficient are “not the focus.” Valve also took “code” out of its list of examples in January 2026. AI art still needs disclosing.

Slimeshot shows the risk. Its Steam page discloses only AI help “with the codebase,” while its developer says Claude made the art too. Players screenshot gaps like that. If you’re worried about how players react, read our data on AI art backlash.

Will Claude Code build a clone of an existing game?

It’s set up not to. In late October 2026, Anthropic added two sentences to Claude Code’s prompt on Opus 5.5, GameDeveloper.com reports. Claude now declines to build “a recreation of a specific existing game,” even under a new name.

Original games, games in an existing genre and games built from your own designs are fine.

Who owns the code Claude writes?

You do, for the parts you shaped. US law draws the line like this:

• Purely AI-generated material can’t be copyrighted, and prompts alone don’t make you the author, per the Copyright Office’s 2025 report.
• Your own selection, arrangement and edits can be protected.
• The Supreme Court declined to hear Thaler v. Perlmutter in March 2026, so the human-author rule stands.

Anthropic’s terms give you whatever rights exist in the output. If you plan to register a copyright, talk to a lawyer.

Start your first Claude Code game this weekend

1. Install Godot 4.7 and create an empty project.
2. Paste the CLAUDE.md above and fill in the blanks.
3. Ask for one mechanic with a number attached, like “a player that jumps three tiles high, plus a test that proves it.”
4. Run the test, then play it yourself. Only then ask for the next mechanic.

FAQ

Do I need to know how to code to make a game with Claude Code?

No, to get a prototype. Yes, to finish something bigger. Non-programmers have shipped small games with Claude Code. Every larger success had someone who could read the code, spot bad structure and decide what to cut.

Is Godot or Unity better for Claude Code?

Godot, for most solo developers. Its scenes are text, and it runs headless from one command, so Claude can check its own work. Unity is close behind now that the Unity CLI lets Claude drive the editor. Pick Unity if you already know it or need its mobile and console tools.

Can Claude Code make game art?

Not on its own. Claude writes code, so it can draw sprites in code, generate sound from code or build tools that cut and fit images. Most Claude Code games pair it with an image or 3D generator, then clean up every asset by hand. See our guide to text-to-3D game assets for that side.

Which Claude model should I use for game development?

Opus 5.5 is the common pick for daily building, and it runs inside Pro limits. Sonnet 5.5 is cheaper, and it wrote all 136,000 lines of one developer’s kids’ game. Fable 5.1 is Anthropic’s top-priced model, and on Pro it bills extra credits.

Is the $20 Claude Pro plan enough to make a game?

For a small game, yes, if you plan sessions and use Sonnet for simple tasks. For daily multi-hour builds, plan on Max at $100.

Can I sell a game made with Claude Code on Steam?

Yes. Fill in Steam’s Content Survey honestly, and disclose any AI-made art, sound or text that ships with the game. Valve no longer lists code among the AI content it asks about.

That split tells you how to use Epic’s new MCP server. It handles setup work well and fails when it has to design a system alone. It’s experimental and has no password, and connecting takes six steps. Everything below comes from Epic’s docs or from named testers.

Jump to: Setup · Command reference · First safe session · What works · Fixes · Cost · Security · Alternatives · FAQ

What the Unreal Engine 5.8 MCP server is

MCP (Model Context Protocol) is an open standard that lets an AI client call named functions in another program. Epic’s plugin, Unreal MCP, runs an MCP server inside the editor process. Claude Code connects over local HTTP and calls tools. Epic’s examples include spawning actors, configuring lighting, creating material instances, inspecting Slate widgets and running automation tests.

Epic shipped it with UE 5.8 on June 17, 2026. The docs mark it Experimental, warn that many features are incomplete or missing, and say APIs and data formats can change at any time. The 5.8.1 hotfix already fixed MCP bugs, so stay on the latest 5.8.x release. For the wider workflow around it, read our guide to Claude for game development.

What you need

• Unreal Engine 5.8 (the plugin is part of that release).
• Claude Code. Epic’s config generator also writes files for Cursor, VS Code, Gemini and Codex.
• A project on its own Git branch, or a throwaway project.

Set up the Unreal Engine 5.8 MCP server in 6 steps

1. Enable the plugins. Open Edit > Plugins, search “Unreal MCP” and tick Enabled, then do the same for “All Toolsets”. Restart when prompted.
   You should see: both plugins checked after the restart. Toolset Registry turns on by itself.
   Skip All Toolsets and you get a server with almost nothing to call. Epic’s docs say the tools come from that plugin, and a forum user who skipped it reported seeing a single toolset.
2. Start the server. Either turn on Edit > Editor Preferences > General > Model Context Protocol > Auto Start Server, or open the console (backtick key) and run:
   ModelContextProtocol.StartServer
   You should see: the bind address, port and path in the Output Log. A failed bind shows up there too.
3. Generate Claude’s config. In the same console:
   ModelContextProtocol.GenerateClientConfig ClaudeCode
   You should see: a .mcp.json file in your project root. Run the command again if you change the port.
4. Start Claude Code from the project root. Open a terminal in the folder that holds your .uproject and .mcp.json, then run claude. Do it after the editor is up. From any other folder, Claude won’t find the server.
5. Approve and check the connection. Claude Code asks you to approve servers from a project’s .mcp.json. Approve it, then run /mcp.
   You should see: unreal-mcp listed as connected.
6. Ask a read-only question. Epic’s own test: “What actors do I have selected?”
   You should see: an answer that matches your editor, which confirms Claude reads live editor state.

The generated file looks like this:

{
  "mcpServers": {
    "unreal-mcp": {
      "type": "http",
      "url": "http://127.0.0.1:8000/mcp"
    }
  }
}

Optional: Epic publishes a Claude Code plugin with usage guidance for the server. Install it inside Claude Code with /plugin install unreal-engine-skills-for-claude-code@claude-plugins-official. The repo says its start-up hook needs bash on your PATH. On Windows that means Git Bash or WSL. The MCP tools work without it.

Commands, settings and defaults

Turn on logging with Log LogModelContextProtocol Verbose. To test the server without Claude, run npx @modelcontextprotocol/inspector and point it at the server URL over Streamable HTTP.

Your first safe session

Epic’s plugin README says MCP tools edit live objects and can change, move or delete tracked assets in a single call. So you start small.

1. Commit or branch first. One clean commit gives you a way back.
2. Read before you write. Ask Claude to list the actors in your level. Compare the count with your World Outliner. If they differ, stop and find out why.
3. Make one reversible change. Spawn a single cube, or rename one actor.
4. Test undo. Press Ctrl+Z. Epic’s 5.8.1 notes changed how transactions behave during tool scripts, so check that undo works for the kind of change you plan to make.
5. Save, then read the diff. Look at what changed on disk. Blueprint edits need this most (see the fixes table).

What it can and can’t do

Puget Systems published a detailed hands-on test. Their tester used Claude Opus 4.8 on the default Blank Game project and stayed hands-off on purpose across four tasks.

The pattern is simple. It’s good at setup work and weak at architecture. Puget’s conclusion was to build a minimal structure by hand first, then let MCP extend it. The tester also admits the walking-controls prompt was vague, and results will shift with your model and prompt.

Epic documents toolsets for the level and camera (SceneTools), actors and their components (ActorTools), materials and material instances, and Blueprints. It also lists Sequencer, automation tests and Slate inspection. It doesn’t publish individual tool names. Ask Claude to run list_toolsets and you’ll see what your build exposes.

Troubleshooting: symptom, cause, fix

Cost, speed and token use

Puget’s waits ran five to ten minutes per request, and some passed fifteen. You can’t keep working in the same project while Claude edits it, so attention drifts.

On a Claude Pro Team plan, the tester used up their session limit before midday and about 15% of the weekly allocation across four small tests. Their estimate was that regular use would burn through every token within a couple of days. Your numbers depend on the model and how tight your prompts are.

Security

• Epic’s docs say the server is loopback-only, has no authentication and isn’t safe to expose. Epic’s README adds that any process running as your user can connect. Don’t forward the port.
• Epic’s API page describes ProgrammaticToolset as a sandboxed script for chaining tools, while the plugin README says its execute_tool_script runs arbitrary Python in the editor. The two descriptions disagree, so plan for the stricter one.
• Puget’s tester saw Claude capture level screenshots to check its own work, so images of unreleased art can reach the model. Keep sensitive art and keys out of the session if that matters to you.
• Telemetry is on by default. The EnableAnalytics variable gates it, and Epic doesn’t document what it sends.
• Epic’s README warns against --dangerously-skip-permissions with this plugin loaded, so keep Claude Code’s approvals on.

Build your own tools

If Claude can’t do a job, you can add the tool yourself. Epic’s recommended route is a toolset class. In Python it derives from unreal.ToolsetDefinition, and each tool is a static method marked with @toolset_registry.tool_call. Type hints and Google-style docstrings become the schema Claude sees. In C++ you derive from UToolsetDefinition and mark functions AICallable.

Python files live under a plugin’s Content/Python/ folder. After a change, run ModelContextProtocol.RefreshTools. Epic’s Claude Code plugin includes a create-toolset skill that scaffolds one. The code samples are in Epic’s Unreal MCP docs.

Official plugin vs third-party servers vs Unity

Unity is different. Its official route now runs through the Unity CLI, and our Claude Code Unity MCP setup covers it. For how Unreal stacks up against Godot and Unity under Claude Code, see Claude Code for game development.

Who should use it

Use it now if you’re on UE 5.8, you know your project well, and you want help with greyboxing, repetitive setup and wiring simple Blueprints. Keep Git on and review every change.

Wait if you’re new to Unreal and hoping the AI fills the gap. Puget’s tester lost track of what the AI had built and couldn’t repair it alone. Wait too if your studio restricts where project data can go, or if you need PCG graphs or player input built from scratch.

Your next step is to run the first safe session on a branch. If the actor count matches your Outliner and undo works, you’re ready for real work.

FAQ

Does UE 5.8 include MCP by default?

The plugin ships with the engine, but you enable it yourself, and Auto Start Server is off until you turn it on.

Is it free?

The plugin is part of the engine. The model side costs money. Claude Code needs a Claude plan or API credits, and Puget’s tester burned through plan limits fast.

Does it work with Cursor, Gemini or Codex?

Epic’s config command writes files for Cursor, VS Code, Gemini and Codex as well as Claude Code, and its docs name Cursor and the MCP Inspector as example clients.

Can it run on a remote machine?

Not safely. Epic says the server is built for local use, with no authentication and loopback binding.

Does it replace Blueprint knowledge?

No. Puget’s tester says it cuts the effort of getting something in place, but you still need to understand what it built.

Sources

• Epic: Unreal MCP in Unreal Editor
• Epic: Unreal Engine 5.8 announcement
• Epic: Claude Code plugin and README
• Epic forums: 5.8.1 hotfix notes
• Puget Systems: Unreal Engine MCP hands-on test
• Anthropic: Claude Code MCP docs

Text-to-3D gives you a fast first draft and a big cleanup bill. Below are the eight tools worth your money for game work, ranked. For each one: the settings that shrink that bill, the real cost per model, and the licence trap in its free tier. Meshy leads for textured props. Tripo leads for clean topology and rigs.

Research-based picks, checked against each tool’s docs, pricing pages, licence terms and published tests.

Quick picks

How text-to-3D works (and why it changes what you buy)

Most text-to-3D tools turn your prompt into a picture first. Then they turn the picture into a mesh.

Rodin’s API docs say it outright: “The prompt is first rendered to an image.” Spline, Ludo, Kaedim and Unity’s generator document the same two-step route. Even Microsoft’s TRELLIS team says its text models are “less creative and detailed due to data limitation” than its image models.

So when you compare tools, compare how well they turn a reference image into a clean mesh. It’s also why the strongest game workflow is image-to-3D with concept art you control, so every asset keeps the same style and proportions.

The output also needs work. Generators extract a dense, triangulated shell with one texture set. Static props survive that, but characters don’t, because anything that bends needs edge loops at the joints and no tool reliably builds them yet.

The 8 best text-to-3D tools for game assets

1. Meshy: best for textured props and fast iteration

Meshy’s strength is texture. In a three-tool test written by a Meshy technical artist, Meshy led on textured output but came last on raw shape. Meshy 6 sits third on 3D Arena, a public leaderboard of human votes on image-to-3D results.

• Game settings: Remesh to a target between 100 and 300,000 faces (default 30,000). In the web app, remesh, rigging and animation cost 0 credits. The free plan only offers a 10K remesh target.
• Textures: PBR maps (base colour, metallic, roughness, normal) up to 8K. Turn on lighting removal, but note it only works on the meshy-6 model.
• Rigging: humanoid bipeds only, with 500+ animations.
• Engines: DCC Bridge to Blender, Unity, Unreal, Godot, Roblox, Maya and 3ds Max on Pro and up.
• Price: Pro $20, Premium $40, Ultra $100 per month. A textured model costs 30 credits, about $0.60 on Pro, and Pro gives you 4 free retries per task.
• Licence: paid users own their output. Free output belongs to Meshy, licensed to you under CC BY 4.0, so you must credit Meshy. Meshy trains on non-Enterprise inputs and outputs unless you email support to opt out.
• Watch out: geometry is the weak spot. In a small Top3D.ai retopology test, Meshy meshes still had non-manifold edges after a merge pass. Raw Meshy 7.1 meshes can reach 80 million triangles before simplification, so always remesh. Look-alike “Meshy” apps from other developers sell weekly plans on iOS, so download from meshy.ai only.

2. Tripo: best for clean topology, quads and rigs

Tripo is built around topology. Its P2.0 model generates quad meshes directly, and its smart low-poly mode targets 1,000 to 20,000 faces. Even in that test written by a Meshy technical artist, Tripo came first on geometry and topology.

• Game settings: quad output, smart low-poly, a face limit, pivot to centre-bottom, forced symmetry and UV export by default.
• Rigging: biped, quadruped, hexapod, octopod, avian, serpentine and aquatic skeletons, with a Mixamo-compatible spec.
• Engines: plugins for Blender, Unity, Unreal, Godot, Maya, 3ds Max, ZBrush and Roblox.
• Price: Pro $20 per month for 3,000 credits, Max $90. A textured PBR model costs about $0.20 on Pro, and Pro lists unlimited free retries.
• Licence: paid users keep their rights, and Tripo’s terms say it won’t use paid users’ inputs or outputs as training data. Free output is public and non-commercial.
• Watch out: the convert step bakes normal and AO detail into the base colour by default, so switch baking off if you want clean PBR maps. Remeshing a rigged model deletes the rig, so fix topology first. API users should set the model version, because the API otherwise uses v2.5, a model from January 2025.

Comparing just these two? Read the full Meshy vs Tripo breakdown.

3. Hyper3D Rodin: best for buildings and size-controlled props

Rodin gives you the tightest size and polygon control. You can pick quad presets of 50K, 18K, 8K or 4K faces, lock the bounding box so a prop fits its space, and force a T or A pose for characters. One developer who couldn’t get Meshy or Tripo buildings under budget put it plainly: “Rodin was used for all buildings.”

• Engines: plugins for Blender, Unity, Unreal and Godot, plus ComfyUI and an MCP server.
• Rigging: templates for UE humans, Unity humans, ActorCore, quadrupeds, birds, dragons and custom skeletons up to 256 nodes.
• Price: Creator $30 per month (about 60 models), Business $120 (about 416 models, with API access). You preview each result before credits are spent, so you don’t pay for rejects.
• Watch out: pick the PBR material mode. The Shaded and Hybrid modes deliberately bake lighting into the colour map, and delighting is off by default. Its Trustpilot score is 2.8 from 57 reviews, with complaints about quality and refunds.

4. Tencent HY 3D: best for clean geometry through an API

HY 3D is the hosted version of Hunyuan3D 3.x. In the same small Top3D.ai test, it produced the cleanest geometry, with zero non-manifold edges and no manual fixes. It’s also the default model inside Unity’s own 3D generator.

• Game settings: face count from 3,000 to 1.5 million (default 500,000, so set it), plus add-ons for smart topology (50 credits), UV unwrap (10) and auto-rigging (10).
• Price: prepaid packs from $15 for 1,000 credits. A textured PBR model costs 35 credits, about $0.53.
• Licence: the API terms assign output rights to you, so use the API for commercial work.
• Watch out: the default concurrency is 3 jobs, and each extra slot costs $5,000 a month. That’s fine solo and a wall for batch pipelines.

5. Sloyd: best for lots of simple props on a flat fee

Sloyd charges a flat fee instead of per-model credits. It also has a parametric template editor that builds models from adjustable parts, which suits clean low-poly furniture and props.

• Price: Plus is $15 per month ($12.50 billed yearly) for “unlimited” text and image generations under fair-use limits. Pro is $50 and adds the right to resell assets on marketplaces. The free guest tier allows 1 generation per day for personal use.
• Engines: free plugins for Roblox, Blender, Godot, Maya, Unity and Unreal.
• Watch out: users report a polygon floor around 5,000, and one reviewer waited up to four days for a support reply.

6. Unity 3D Object Generator: best for static props inside Unity

Unity’s in-editor generator, in open beta since May 2026, drops a prefab with mesh and materials straight into your project. Its default model is Hunyuan 3D 3.0 Pro, and a text generation costs about 8 Unity credits.

• Limits: simple single-part props only. No rigging, no animation. Text prompts make a reference image first.
• Price: included on Unity Pro. Personal users get a trial, then pay $10 per month.
• Useful detail: every asset carries embedded metadata that flags it as AI-generated, which helps when you fill in Steam’s AI disclosure.

7. Autodesk Wonder 3D: best for free experiments

Autodesk added Wonder 3D to Flow Studio in March 2026. It turns text, images or sketches into 3D, then offers remesh and texture passes. Each generation costs 20 credits on every plan, including the free one.

• Watch out: its launch post lists no export formats or PBR details, and says generated assets “should be reviewed before production use.” Treat it as a sandbox until you’ve checked the output.

8. Free and open source: TRELLIS.2 and Pixal3D in ComfyUI

If you have a GPU, you can generate locally for the cost of electricity. The cleanest route is ComfyUI’s native TRELLIS.2 and Pixal3D nodes. ComfyUI rebuilt them without NVIDIA’s non-commercial rendering libraries and calls the result “free to use, including commercially.”

• Hardware: official TRELLIS.2 needs 24 GB of VRAM on Linux. The trellis.cpp port runs it on 16 GB cards, AMD and Apple Silicon. Stable Fast 3D runs on about 6 GB.
• Cloud option: a rented RTX 4090 costs about $0.34 an hour. At roughly 3 minutes per model, that’s a few cents of GPU time each.
• Licence trap: Hunyuan3D 2.1 ranks higher on 3D Arena than TRELLIS.2, but its licence “DOES NOT APPLY IN THE EUROPEAN UNION, UNITED KINGDOM AND SOUTH KOREA” and covers outputs. Any game sold there is exposed, wherever you live.
• Watch out: these models take images, not text, so pair them with an image generator. Installs on Windows can take days.

Tools you’ll still see recommended that no longer work

Skip these three if a list recommends them. None of them generates anything today.

• Luma Genie shut down on January 1, 2026, yet 2026 “best of” lists still recommend it as the best free option.
• CSM Cube went offline after Google bought Common Sense Machines in January 2026. Its old model, listed as “PicGen3D”, still sits first on 3D Arena.
• Masterpiece X Generate is now a legacy app that no longer loads.

What a usable asset really costs

Credits are the cheap part of a usable asset. Per textured model, they cost cents:

Now add the human time. One independent review timed 25 minutes of retopology and UV cleanup on a single 42,000-triangle Meshy helmet. A US special-effects artist’s median wage is $49.06 an hour (BLS), so that one cleanup costs about $20 of labour against $0.60 of credits. Outsourcing studio Pixune quotes $500 to $2,500 for one hand-made 3D prop, so AI plus an hour of your own cleanup still costs a fraction of a commission.

So pick the tool whose output needs the least fixing for your asset type, even if its credits cost a little more.

The game-ready checklist

A model is game-ready when it passes these ten checks:

1. Triangle count fits your budget (Quest 2 targets under 750,000 triangles per frame in total, per Meta).
2. No holes, floating parts or non-manifold edges.
3. Clean UVs without overlaps.
4. PBR maps with no lighting painted into the colour.
5. Real-world scale in metres.
6. Pivot at the base, or at the hinge for doors and lids.
7. A simple collision mesh.
8. LODs for distance.
9. Imports without errors or wrong materials.
10. A rig that deforms cleanly, if it moves.

Static props usually pass after decimation, LODs and a scale fix. Characters fail at step 10 most often. In a Meshy technical artist’s 50-asset Unity project, 10 of 15 AI humanoids failed auto-rigging “due to irregular topology.”

From generated mesh to engine: the cleanup pipeline

1. Generate with game limits on. Set a face target, quads or low-poly, and PBR before you generate.
2. Clean. Merge vertices by distance, delete loose parts and recalculate normals in Blender.
3. Fix scale and pivot. Size it in metres and put the origin where the object rotates or rests.
4. Fix topology. Decimate static props. Retopologise anything that deforms, with Blender’s QuadriFlow or Quad Remesher. Quad Remesher’s $59.90 Indie licence is “NOT usable for commercial purpose”, so buy Pro at $109.90 if you sell your game.
5. Unwrap and bake. Treat the AI mesh as your high-poly. Bake normals and the base colour onto your clean low-poly. In Blender, tick only “Color” in the Diffuse bake so you don’t bake light into it.
6. Shrink textures. Four 4K maps eat about 85 MB of VRAM with mips in BC7. Most props look the same at 1K or 2K.
7. Add LODs and collision. Then import.

Batch steps 2, 6 and 7 with the free glTF-Transform command line. Pass flags on purpose, because its optimize command simplifies geometry by default.

Import notes for Unity, Unreal and Godot

• Unity: import GLB with the glTFast package. glTF packs roughness in the green channel and metal in blue, while URP’s packed map wants metal in red and smoothness (1 minus roughness) in alpha. Repack once with a script. Unity 6.2 and later can generate LODs at import with one checkbox (Mesh LOD). It ignores skin weights, so use it for props, not characters.
• Unreal Engine 5: Nanite renders dense static meshes well on PC and console, but it doesn’t support VR stereo rendering or translucency, and it stores about 14.4 bytes per triangle on disk (Epic). FBX import only connects colour and normal maps automatically. Name collision meshes UCX_ so Unreal picks them up.
• Godot: glTF is the recommended format. Blender exports materials with backface culling off by default, so turn it on before export. Add “-colonly” to a mesh name to import it as collision. More in our guide to using AI with Godot.

Making a 2D game? Render your 3D models into sprite sheets. Our sprite sheet generator guide covers the tools.

Rights, Steam disclosure and how players react

Who owns AI-generated 3D models

“Commercial use allowed” doesn’t mean you own a copyright. The US Copyright Office says “the mere provision of prompts” isn’t enough for protection, but your human edits and arrangements can be protected (USCO). Meshy’s own terms warn that output “MAY NOT QUALIFY FOR INTELLECTUAL PROPERTY PROTECTION.”

Steam’s AI disclosure

Since Valve rewrote its rules in January 2026, code helpers fall outside the disclosure, but AI content in your game or on your store page still counts. One developer’s disclosure shows the honest format: Tripo models “are used as a base for some 3D assets. The developer performs mesh editing, scaling, texture and normal map adjustments.” Full rules in our Steam AI disclosure guide.

How players react

In a Quantic Foundry survey of 1,799 gamers, 85% rated generative AI in games below neutral (source). Yet AI-disclosed games made up 30.8% of Steam releases in 2026 through July, by Sulka Haro’s count of 53,597 games. Art drew more negativity than other uses, so keep AI models in the background and hand-finish your hero assets. More data in will players punish AI art.

Game jams and asset stores

GMTK Game Jam disqualifies AI-generated art. TurboSquid bans AI models. Fab, Sketchfab and the Unity Asset Store accept them with an AI tag.

FAQ

That’s Coding-Solo/godot-mcp. The star count comes from GitHub’s API, and the tool count comes from counting tool registrations in its source. Both were checked.

A high star count shows attention. It says little about which server will read your scene tree and run your game without damaging your project files, and the directories that list these servers add no testing.

This page sorts by fit. It compares eight servers in one table and walks through a setup for Claude Code.

Jump to: comparison table | setup | reviews | safety | FAQ

Which Godot MCP server should you install for Claude Code?

For Godot 4.7 or newer, install hi-godot/godot-ai. It’s free and MIT licensed, has 47 tools by our count, and shipped v4.3.0 on October 3. On an older Godot 4.x, use Erodenn/godot-mcp-runtime, which installs with one npx command and needs Node 20 or newer. If you only edit scripts, skip MCP and let Claude Code use the terminal.

MCP lets Claude read your scene tree and run the editor as well as edit files.

We checked specs, source code, and docs but did not run the servers.

How did we check these servers?

We sell no engine, plugin, or MCP server, and this page has no affiliate links.

The numbers come from GitHub’s API, each repo’s README and source, vendor pages, and the Claude Code docs. “Counted” means we counted tool registrations in the source. “README” and “vendor” mean we took the project’s word for it.

We did not install or run any server, so this page has no setup times, token counts, or pass and fail scores. The section on testing a server gives you five prompts to check any of them yourself. This page also does not cover:

• How an install behaves on Windows, macOS, or Linux
• Token use per server
• Whether the paid servers deliver the tool counts their vendors claim
• Any Godot version below the minimum each project states
• Whether any server can finish a real game

What is Godot MCP?

MCP is a standard that lets an AI client call tools on a server. A Godot MCP server gives Claude tools like add_node and run_project, so it can act on your project directly.

Servers come in three architectures, and many mix two.

The chain runs from Claude Code to the MCP server to Godot, which is either headless, the open editor, or the running game.

A successful tool call proves the command ran. It doesn’t prove the game plays right, so you still have to play it.

Do you need MCP at all?

Maybe not. Claude Code already runs shell commands, so it can call Godot itself.

godot --version
godot --headless --path . --quit
godot --headless --check-only --script res://player.gd

The first command prints the version. The second loads the project without a window and exits. The third parses one script and reports errors. If Godot isn’t on your PATH, use the full path to its executable, and run godot --help to confirm the flags on your version.

That covers script edits and syntax checks. MCP adds what the terminal can’t see: the live scene tree, editor errors, running-game state, and screenshots.

How do the eight Godot MCP servers compare?

Sorted by our pick for Claude Code. Stars and dates move weekly.

Also on our list: Godlink (tomyud1) with 438 stars and Godot 4.4+, satelliteoflove with 21 tools and Godot 4.5+, GoPeak on Bun, and Fennara written in Rust. We did not verify their full tool counts.

How do you set up Godot MCP with Claude Code?

You need Claude Code and a Godot 4.x build that meets your server’s minimum. Runtime needs Node 20 or newer, Coding-Solo needs Node 18 or newer, and godot-ai needs uv.

Make a Git checkpoint first, because an MCP server edits files and some edit project.godot.

git init
git add -A
git commit -m "before MCP"

Option A: godot-ai (Godot 4.7+)

The README gives no single command, so you install it by hand:

1. Download a release from the godot-ai releases page.
2. Put the add-on in your-project/addons/godot_ai/.
3. Enable it in Project Settings, Plugins.
4. Press Configure in the Godot AI dock. It writes the client config.

Option B: Godot MCP Runtime (any Godot 4.x, Node 20+)

claude mcp add godot -e GODOT_PATH=/path/to/godot -- npx -y godot-mcp-runtime

Everything after the double hyphen is the server command. Everything before it is Claude Code’s own flags. The Runtime README shows the same setup as a JSON config. Add --scope project to write a shared .mcp.json, or --scope user to use the server in every project. The default scope is local to you and this project. The Claude Code MCP docs list these flags.

Check that it works

claude mcp list

A working server shows ✔ Connected. Start a session and run /mcp to see its tools. Then give Claude a read-only first task:

List every node in res://main.tscn. Do not change any file.

If Claude answers from the file instead of calling a tool, ask which MCP tool it used. No tool means the server isn’t connected. Our guide on using AI with Godot 4 covers the “Connection closed” error.

Windows, macOS, and Linux snags

• On Windows, GODOT_PATH must point to the executable, not the folder. Escape backslashes or use forward slashes (Runtime README). If an npx server won’t start, wrap it as -- cmd /c npx -y package-name, the form the Godlink README uses.
• godot-ai has two open Windows issues: #1105 (self-update intermittently blocks) and #1089 (editor startup took 193 seconds before the server attached).
• On macOS, point GODOT_PATH at the binary inside the app bundle, not at the .app.
• On Linux, the godot-ai README has notes for Bazzite and Fedora Atomic, and for Steam and Flatpak installs.

What should you know about each server?

hi-godot/godot-ai: best free pick for Godot 4.7+

An editor plugin plus a Python server started with uvx. It’s MIT licensed, has 3,071 stars, and shipped v4.3.0 on October 3. We counted 47 tools against the README’s 46, and 28 of them are <domain>_manage tools that hide many operations behind an op argument, so the count understates what it does.

It needs Godot 4.7 or newer, and the open issues lean Windows. It sends opt-out anonymous usage telemetry (set GODOT_AI_DISABLE_TELEMETRY=true to turn it off), and editor_manage includes game_eval, which runs code in the running game.

It suits Godot 4.7+ projects where you want live editor control. Pass if you’re on an older 4.x or dislike opt-out telemetry.

Godot MCP Runtime: easiest free install

It edits headless and checks the running game through a temporary bridge it injects when you run the project and removes when it stops. It’s MIT licensed with 93 stars, and v3.8.1 shipped September 25. We counted 39 tools, and it needs Node 20+.

run_script executes GDScript in the live game, and the project’s own security doc calls its guard best-effort and “not a sandbox”. A hard kill can leave the bridge autoload in project.godot (issue #71), so commit first.

The repo’s author also wrote the comparison table that ranks it, so we don’t use that table’s verdicts.

Choose it for one-command setup on any 4.x. Skip it if you can’t accept edits to project.godot.

Coding-Solo/godot-mcp: most stars, fewest tools

It’s MIT licensed, with 6,154 stars and 14 tools by our count: launch the editor, run a project, read debug output, create a scene, add a node, save, and handle UIDs. The repo has no release or tag, and the only npm version is 0.1.1 from February 3.

Pull request #99, merged April 16, says add_node and create_scene could load an arbitrary script through the node-type parameter. npm hasn’t published since, so npx likely serves the build from before that fix. We did not diff the package. To check, run npm pack @coding-solo/godot-mcp and look at the node-type handling. The repo has 40 open issues and 35 open pull requests.

It fits a small surface if you install from source. Skip it if you want an actively maintained server.

tugcantopaloglu/godot-mcp: most tools, most risk

A fork of Coding-Solo, MIT licensed, with 493 stars and v3.1.0 from July 13. Our count of 157 tools matches the README, and it needs Godot 4.4+. You install it with git clone, npm install, and npm run build, not npx, because the npm package is stuck at 1.0.0.

Its tools include game_eval, write_file, delete_file, and game_http_request, the largest permission surface of the servers here. GODOT_MCP_ALLOWED_DIRS restricts project roots, and the README recommends a separate account or container for untrusted projects.

Open issues: #25 says get_debug_output returns all accumulated output on every call, so it grows each run. #22 reports Windows shell-escaping failures, and #31 says VS Code Copilot rejects some of its schemas.

Take it if you want the widest toolset and will scope it. Skip it if you want a small tool surface.

IvanMurzak/Godot-MCP: the C# pick

It’s a C# editor addon, and nothing else here needs the mono build. It’s Apache-2.0 licensed with 295 stars, and v0.30.0 shipped October 19. Our count of 23 tools matches the README, and four of them are hidden system tools. Most editing goes through three query tools.

It needs the mono build of Godot 4.3+, the .NET 8 SDK, and Node for its godot-cli installer. The standard Godot build can’t compile the addon.

By default it connects to a hosted backend, ai-game.dev, through an OAuth login, though you can self-host. script-execute compiles and runs arbitrary C# in the editor. The repo was created June 4 and ships fast, so expect churn. One issue is open.

It’s the pick for a C# project. If you use GDScript or don’t want a hosted backend, skip it.

Godot MCP Pro: $15, closed, and its pages disagree

The itch.io page sells it for $15 once and claims 163 tools. The Godot forum launch thread quoted $5 and 162 tools, and other vendor pages say 187. The Asset Library lists the license as proprietary, while a vendor page calls the plugin open source. We found no refund policy.

All three counts are vendor-claimed, and we haven’t installed it. One forum reply says MCP “consumes a lot of token”, but nobody in that thread measured anything.

It makes sense if you want to pay once and accept the counts until someone verifies them. If a free server already covers your task, skip it.

GDAI MCP: $19, closed source

The license page says the plugin is distributed in binary form only. Summer Engine’s GDAI alternative post gets this wrong and calls it open source. The vendor lists $19 once and 31 tools on its docs page, though the changelog names tools that list omits, so the real count may be higher. Minimum Godot is 4.2 on the site and 4.1 on GitHub.

Choose it if you want a closed plugin you install once. You should skip it if you need to read the source before you trust it.

Godot-MCP-Native: no Node or Python, least verified

It runs as pure GDScript inside the editor. It’s MIT licensed with 859 stars since its May 4 creation, and v1.0.8 shipped July 26. It serves HTTP on port 9080 by default, or stdio. The README claims 155 tools (30 core, 125 extra), and we did not count them. Two open issues report it failing to load in Codex CLI.

It’s for people who don’t want Node or Python installed. Anyone who needs verified claims should look elsewhere.

Ziva and Summer Engine: vendors with their own roundups

Both sell products, and both publish roundups that rank themselves. Ziva is an in-editor agent with a free Hobby tier, then $20, $50, and $200 a month, and a vendor-claimed 163 tools. Summer Engine is a standalone engine app built on Godot, with plans from free to $200 a month. Its MCP server is MIT.

Ziva’s 21-tool roundup counts 21 AI tools, and only 7 are MCP bridges. Its authors say they did not install every paid plugin. Summer’s MCP guide uses a placeholder repo, github.com/example/godot-mcp.

How do you test a server yourself?

Use one project, one model, and a fresh session per server, starting with a scene named res://main.tscn. Put this line first in every prompt so Godot 3 code doesn’t creep in:

This is a Godot 4.x project. Use GDScript 2.0 only: @export, @onready, await, signal.connect(callable), CharacterBody2D. Never use yield, KinematicBody2D, or the string form of connect.

1. Read: List every node and script in res://main.tscn. Give node name, type, and script path. Do not change any file.
2. Create: Add a Player (CharacterBody2D) to res://main.tscn that moves with the arrow keys at 200 pixels per second. Add a Pickup (Area2D) that emits a collected signal, and show the count in a Label.
3. Debug: res://player.gd fails to load. Find the cause and fix it. Change only what is broken. (Seed a wrong node path and one Godot 3 line in that file.)
4. Runtime: Run the game, take a screenshot, and tell me what is on screen.
5. Scope: Refactor res://enemy.gd to use a state enum. Do not touch any other file. List every file you changed.

Record setup minutes, tokens used, wall time, and pass, partial, or fail for each task. For tokens, run /context before the first prompt and after the last.

How many tokens does Godot MCP use?

Tool count matters less than it looks, as long as tool search is on. Claude Code defers MCP tool definitions by default: only tool names load at session start, and full definitions load when Claude needs them. A server with 157 tools doesn’t put 157 schemas in your context on a default setup. Tool search turns off with ENABLE_TOOL_SEARCH=false, behind a proxy that isn’t first-party, and on models before Claude 4. Source: the Claude Code MCP docs.

Most tokens come from tool output. Claude Code warns when one MCP result passes 10,000 tokens and caps results at 25,000 by default. Raise the cap with MAX_MCP_OUTPUT_TOKENS. Screenshots count too.

Some servers return a lot by default. The tugcantopaloglu issue above is one example: debug output that grows on every call.

To keep usage down:

• Ask for scoped reads, such as “list the children of Player” instead of “list the project”.
• Run one task per session and use /clear between tasks.
• Remove servers you aren’t using with claude mcp remove.
• Check /context after your first task and compare servers.

A forum reply says MCP uses a lot of tokens. We found no per-server measurement anywhere, so measure your own with /context.

What breaks when Claude writes Godot code?

Godot 3 syntax in a Godot 4 project

Claude can slip into Godot 3 syntax, usually in these forms.

Add the Godot 4 line from the testing section to your prompt. Our Godot 4 AI guide has the full translation table.

Hand-edited .tscn files

A scene won’t load, or a node vanishes after an edit. The likely cause is that Claude edited the scene text and broke a resource ID. Let the MCP tools edit scenes, and revert with Git if one breaks. Godot 4.4 added .uid files next to scripts, so don’t let Claude delete them. Prompt line: Edit scenes with the MCP tools. Never edit .tscn text directly.

Signals and node paths

A signal never fires, or you get a null instance. The likely cause is a guessed path like $Player that doesn’t match the real tree. Read the scene tree first and use unique-name nodes (%Player). Prompt line: List the scene tree before you write any node path.

Game feel

Code that follows the camera correctly can still lurch. Claude can’t feel the game, and a success response doesn’t mean it plays well. Use a runtime server for screenshots, then play it yourself. Prompt line: Run the game and describe what moves on screen. Don’t say it works until you’ve seen it.

Is Godot MCP safe to run?

An MCP server runs with your user account’s permissions, so scope it. This table comes from the READMEs, docs, and source of the five open-source servers we read.

We did not assess Godot MCP Pro, GDAI, or Godot-MCP-Native. The first two are closed source.

1. Commit before you let any server edit files.
2. Open /mcp and read the tool list. If you see game_eval or run_script, know what they do.
3. Start with a read-only task.
4. Scope paths. For tugcantopaloglu, set GODOT_MCP_ALLOWED_DIRS.
5. Keep untrusted projects in a separate account or container. The tugcantopaloglu README advises this because eval and generated scripts run with your account’s rights.
6. Don’t switch Claude Code to a bypass-permissions mode with these servers. The Runtime docs say its confirmation prompts are auto-answered in those modes.
7. Keep API keys out of prompts and out of the project folder.

Claude Code, Cursor, Copilot, or an in-editor plugin?

We found no independent benchmark that compares these on the same Godot project. If you work in Unity, we wrote the same comparison there: Claude Code vs Cursor for Unity. For how Godot compares with Unity and Unreal under Claude Code, see Claude Code for game development.

Godot MCP FAQ

Which one should you pick?

• On Godot 4.7+ with live editor work, use godot-ai.
• On an older Godot 4.x, use Godot MCP Runtime for one-command setup.
• For a C# project, use IvanMurzak/Godot-MCP.
• For the most tools, use tugcantopaloglu/godot-mcp and scope it.
• If you only edit scripts, skip MCP and use the terminal.

These picks come from specs, source counts, and open issues. We did not run the servers.

Changelog

• October 19, 2026: first version. Specs, prices, licenses, tool counts, and issues checked against GitHub, vendor pages, and the Claude Code docs.

Claude Code is the better agent for most Unity 6 projects. Cursor is the better editor for code-heavy apps. Both cost $20 a month. Cursor’s catch: Microsoft’s C# and Unity extensions are licensed out of it. Claude Code’s catch: its checkpoints skip anything done through the shell, so Git is your undo button.

Prices and limits checked on vendor pages. Unity details from Unity’s manual, GitHub repos and developer threads.

The short answer

Pick by how you work. A wrong pick costs a month’s fee plus the setup time. Find your row.

Not sure which row is yours? Run the 20-minute test at the end before you pay for a second month.

The real problem is the Editor

Both tools write competent C#. Neither can see your scene.

One solo dev wrote, “It writes solid C#, but the friction is everything that lives in the Editor: scenes, prefabs, serialized fields, animation setup.”

Scenes and prefabs are serialized YAML. Unity’s manual says “You cannot externally produce or edit UnityYAML files.” One developer who tried anyway said editing .unity text “will eat all of your quota and it will take forever.”

A bridge fixes part of it. That means an MCP server or Unity’s CLI that lets the agent act inside the open Editor. These still break:

• Moving or renaming an asset outside Unity breaks its .meta references, and a terminal mv counts. Unity’s manual says “If an asset loses its .meta file, any reference to that asset is broken in your project.”
• Every script change triggers a domain reload, and a reload can drop the bridge. The mcp-unity README documents connection failures in Play Mode tests for this reason.
• A broken script puts the Editor in Safe Mode, where Unity’s pipeline package never loads. The agent loses its connection until you fix the code.
• Unity won’t open a project in batch mode while the Editor has it open, so headless test runs need the Editor closed.
• FindObjectOfType is deprecated in Unity 6 in favor of FindFirstObjectByType. Developers disagree on how often models still suggest the old call, so scan for it.

Unity developers settle on one workaround. Ask the AI to write an Editor script, then run it yourself. One dev on Unity Discussions called it “the only deterministic interface Unity reliably accepts.”

Letting the agent move, rename or delete assets with shell commands. Unity can’t update the .meta files, and Claude Code’s checkpoints don’t track shell changes.

Claude Code vs Cursor at a glance

Claude Code is a terminal agent and Cursor is an AI editor. That difference explains most of the table.

Cursor for Unity: strong AI, awkward IDE

Cursor’s AI handles Unity C# fine. The IDE side is where you pay.

Microsoft licenses C# Dev Kit “only with Microsoft Visual Studio Code, vscode.dev, GitHub Codespaces … and successor Microsoft, GitHub, and other Microsoft affiliates’ products and services.” The official Unity extension sits in the same license family.

Cursor says so itself. On its C# page, Microsoft’s extensions “are licensed for use only in VS Code, so they don’t run in Cursor.” It recommends ReSharper or DotRush and never mentions Unity.

A Cursor staffer was blunter in May 2025: “the official unity extension is closed-source so it is not supported in Cursor.” Unity’s manual lists three supported IDEs: Visual Studio, VS Code and Rider.

Quality reports conflict. One dev called the C# extensions “fundamentally broken” with “extraordinarily high” memory use on a 64 GB machine. Another found DotRush with its Unity debugger “much lighter and more stable than using Microsoft’s C# and Unity extensions together.” Expect to try both.

The C# 14 gap in Cursor’s bundled extension sounds scary and doesn’t matter here. Unity 6.3 compiles C# 9.0.

Set up Cursor for Unity

• DotRush or ReSharper
• .NET Install Tool
• com.unity.ide.cursor
• Paid plan (for MCP)

1. Remove Microsoft’s C#, C# Dev Kit and Unity extensions if they came over from VS Code.
2. Install DotRush (nromanov.dotrush on Open VSX) or ReSharper from its VSIX, plus the .NET Install Tool.
3. In Unity, open Package Manager, choose Add package from git URL, and paste the community package URL below.
4. Go to Edit > Preferences > External Tools, set External Script Editor to Cursor, then click Regenerate project files.
5. To debug, press F5 and pick Unity Debugger (DotRush). Use launch type unity and request attach.
6. Add the .cursorignore below so the index skips generated folders.
7. Put project rules in .cursor/rules/*.mdc, because plain .md files there are ignored. AGENTS.md also works.
8. Optional: in mcp-unity, click Configure Cursor (Project). It writes .cursor/mcp.json.

Package Manager URL

https://github.com/boxqkrtm/com.unity.ide.cursor.git

The boxqkrtm package is a community project (MIT, 1,689 stars). Since v2.0.24 its package name is com.boxqkrtm.ide.cursor. Without it, pointing Unity at Cursor.exe opens files but doesn’t generate .csproj files, so IntelliSense breaks.

.cursorignore

Library/
Temp/
Logs/
Build/
obj/
*.meta

A standard Unity .gitignore already covers Library, Temp, Logs and obj, and Cursor honors .gitignore. The extra lines are Build and .meta.

Installing Zlorn.vstuc from Open VSX. It’s a third-party copy of Microsoft’s Unity extension, and running it in Cursor still breaks the license terms above.

Where Cursor wins

• Inline review shows each change in the editor before it lands.
• Tab completion is unlimited on Pro, so everyday typing never costs extra.
• The index is local. Cursor’s docs say it doesn’t upload your code to build its search index. It also “does not store embeddings of your codebase for search.” That matters if your studio worries about IP.
• Code-heavy Unity apps work well. A dev at a Unity day job writes, “I use cursor almost exclusively. Although our software is UI heavy and has very little to do with 3D stuff in the scene.” An AA studio dev says “everyone has cursor licences.”
• Cursor’s agent runs inside JetBrains IDEs through ACP since March 2026. Cursor’s post doesn’t name Rider, so check before you count on it.

Two gotchas. MCP tools and the terminal ignore .cursorignore, so it isn’t a lock. And Cursor documents no way for Cloud Agents to run the Unity Editor.

Claude Code for Unity: an agent that can drive the Editor

Claude Code runs next to whichever IDE you already use. It reads the whole project and edits across files. With Unity’s plugin or an MCP bridge it can also act inside the Editor.

Install Unity’s plugin

Claude Code session

/plugin marketplace add Unity-Technologies/unity-agent-plugin
/plugin install unity@unity-agent-plugin

The plugin needs Unity 6 and ships 32 skills, including ui-uitk, migrate-birp-to-urp, implement-in-app-purchases, localization and setup-multiplayer-services. It drives the open Editor through Unity’s experimental CLI instead of MCP. It can “create and modify GameObjects, edit scenes and assets, inspect the hierarchy, and run arbitrary C#.”

It’s version 0.1.8-beta, so expect changes. Unity also lists Codex and Grok as supported agents. Cursor isn’t on the list.

Run tests headless

PowerShell

Unity.exe -runTests -batchmode -projectPath <path> -testResults results.xml -testPlatform EditMode

Don’t add -quit. Unity’s test docs say it makes the Editor quit “before in-progress tests have chance to complete.” Close the Editor first, then let Claude read the results XML. Run claude -p with --output-format json and the output includes total_cost_usd, so you can log what each run cost.

Trusting /rewind. Anthropic’s docs say “Checkpointing does not track files modified by Bash commands.” Anything Unity changes through a bridge also happens outside Claude’s edit tools. Assume /rewind can’t undo it. Unity’s plugin README also tells you to commit before asking for larger changes.

Memory, plan mode and limits

• CLAUDE.md loads every session. Keep it under 200 lines and name your Unity version, render pipeline and input system. Templates are in the Claude for game development guide.
• Plan mode (Shift+Tab) makes no edits until you approve the plan.
• Subagents keep verbose test and log output out of your main context.
• MCP output warns at 10,000 tokens and caps at 25,000 by default, so don’t ask a bridge to dump a whole hierarchy.

Unity bridges, side by side

Every MCP bridge works with both tools, and only Unity’s own plugin picks a side. Stars are from the GitHub API. Install steps live in our Claude Code Unity MCP setup guide.

Bridges break in documented ways. Claude Code’s tracker has a closed report of Coplay tool calls timing out after about four conversation compactions. Unity closed a bug as Won’t Fix. With two Editors open, the official MCP connection can reset.

Unity’s CLI (July 2026) is the newer layer underneath. In Unity’s words, “Unity’s AI is one consumer of it, not a replacement for it.” Unity hasn’t called MCP deprecated.

What each one costs

Both start at $20 and both throttle heavy agent use. They meter it differently.

Neither vendor publishes absolute limits. Unity developers report hitting both:

• One Cursor user on a co-op Unity game wrote, “I’ve used 34% of my usage on cursor models, and 65% on other models.”
• A reply in the same thread says, “Using anything but Grok and Composer in cursor for game dev will eat all your monthly usage in a few prompts.”
• A Claude Code user running Fable to plan, Opus to orchestrate and Sonnet workers wrote that it “burned through my weekly limit in just 2 days.”

So the sticker price tells you little, and cost per task tells you more. The test near the end measures it.

Which fits your project

Match the row to your project.

Use both

You don’t have to pick. These setups show up in real Unity threads:

• Claude Code in Rider. One dev says “The integration in Rider with CC Beta has been great.”
• Visual Studio or VS Code with Claude Code in the terminal keeps Microsoft’s Unity tools licensed and working.
• Cursor for code with Claude as planner. One reply says “Get a Claude subscription, use Opus as your planner.”
• Claude Code works inside Cursor because Anthropic’s extension installs there. You still need Cursor’s C# setup and two subscriptions.

Unity AI, Codex, Copilot and Bezi

• Unity AI has been in open beta since May 2026, at $10/mo on Personal after a 14-day, 1,000-credit trial. One subscriber reported being “stuck in a CapacityLimit loop” on its MCP server.
• Unity’s plugin supports Codex alongside Claude Code.
• Copilot works in Rider and Visual Studio. One dev wrote, “I set it up with Rider + Copilot and it’s pretty great so far.”
• Bezi is an in-engine assistant that users say runs on Claude models.

Guardrails that stop AI slop in a Unity project

1. Commit before every session. Unity’s plugin README says so, and /rewind can’t be trusted with Unity changes.
2. Start in plan mode. The agent proposes and you approve.
3. Write the rules down. List your Unity version, render pipeline, input system, and “use FindFirstObjectByType instead of FindObjectOfType.” Say what architecture you want too. One dev says “It loves singletons and tends to couple everything together.”
4. Lock the Editor state. A dev’s AGENTS.md rule reads “Do not modify scenes, prefabs, or serialized Unity assets when the Unity editor state is unsafe or dirty.”
5. Ask for an Editor script when you need scene changes, and run it yourself.
6. Play it yourself. As one Claude Code user put it, “The only reliable loop was to test it myself, capture exactly what happened, then send Claude back into that narrow problem.”

Start every new bridge with a read-only prompt, like “list the GameObjects in the open scene.” If it can’t answer, don’t let it write.

What developers and the data say

Skepticism is common in this industry, and the numbers back it.

• GDC 2026 (2,300+ game professionals): 52% say generative AI is having a negative impact, up from 18% in 2024. 59% of game programmers are unfavorable.
• Stack Overflow 2026 (12,255 developers who used a coding agent): 65.5% had used Claude Code and 25.5% Cursor. That’s all developers, so don’t read it as Unity data.
• No poll splits Claude Code and Cursor users among Unity developers, and no public benchmark compares the tools on C# or Unity. Terminal-Bench 4.0 ranks model and harness pairs on terminal tasks, and Cursor has no entry.
• Unity’s own survey (vendor, 300 respondents) lists coding assistance at 62%.

Test both on your project in 20 minutes

Specs only go so far. Put both tools on one small project and compare.

1. Commit a clean branch of a small project.
2. Give both tools the same three prompts: add a feature across four scripts, fix a NullReferenceException from the console log, and write EditMode tests.
3. Record time, usage consumed, compile errors and anything you fixed by hand. Claude Code shows cost with --output-format json. Cursor shows a usage percentage in its dashboard.
4. Check git diff for changed .meta files and touched scenes.
5. Repeat on the task you dread most.

FAQ

Final verdict

Choose Claude Code if you want an agent that builds across files and drives the Editor, and you’re fine with Git as your undo button. Choose Cursor if you review every change in an editor and your project is mostly code.

If you already work in Rider or Visual Studio, keep it and add Claude Code beside it. Whatever you pick, commit before every session.

Not sure yet? Run the 20-minute test above before you pay for a second month. Then grab the CLAUDE.md templates in the Claude for game development guide and the install commands in the Claude Code Unity MCP setup guide.

Prices and limits change often, so confirm them on the vendor pages before you pay.

We analysed 352,296 Steam reviews. On games caught using AI, 79% of reviews that mention it are negative. On games where AI is the selling point, it’s 26%, about the same as the rest of their reviews. Art and store images draw the fire. Code shows up in 2.4% of complaints. Below are five real cases and a ladder for using AI without paying for it.

The short answer

Yes, sometimes. Visible AI is the trigger. If a player can see it or hear it, they will judge it. That means your capsule art, your cutscenes, your voices and your in-game art.

Hidden AI mostly isn’t a problem, because players don’t review your code or your build pipeline.

Rule of thumb: if it ships where a player can see it, disclose it before someone finds it.

What the sales data says

You’ve probably seen the claim that AI cuts sales by 53%. It comes from a Game Oracle analysis published in December 2025.

The study looked at 9,879 paid Steam games released between January and October 2025. Games with an AI disclosure got an estimated 52.6% fewer reviews in their first month than comparable games without one. Game Oracle used reviews as a stand-in for sales, so it’s a review count, not revenue.

It’s also a correlation. The author says the results “could still be biased” because marketing, skill and budget are hard to measure. And the effect wasn’t even. For low-quality games, AI “makes no difference.” The penalty showed up for high-potential games from experienced developers.

So the better your game, the more AI can cost you.

Two other datasets point the same way:

• Sulka Haro counted 53,597 Steam games released between July 2023 and July 2026. About one in three new releases now discloses AI. Those games reach 100 reviews at 55% of the rate of games without AI. That gap hasn’t closed in two years.
• A peer-reviewed study by Bazzaz and Cooper at Northeastern analysed 508,192 Steam reviews. AI-disclosed games were recommended 68.4% of the time. Games tagged procedural generation got 86.3%.

GameDiscoverCo’s numbers point the other way. It surveyed about 3,800 Steam fans in July 2026. Only 8% said they just won’t buy a game with AI. 43% said they have no big issue with it.

So most players won’t boycott you. But the ones who care write reviews, and reviews are what the next buyer reads.

What 352,296 Steam reviews told us

Surveys tell you what players say, but reviews show what they do, so we built our own dataset.

We pulled English reviews for 49 games. Some had a documented AI controversy, some were built around AI, and some were popular games with no AI at all. We added 246,338 Reddit comments from threads about AI in games and 32,285 YouTube comments. That’s 284,462 comments in total.

Then we flagged the ones that talk about generative AI. We hand-checked a random sample of 371 to make sure the filter worked. Between 97.7% and 99.3% were correct, depending on the platform.

On games caught using AI, 78.9% of reviews that mention it are negative. Across all reviews of those same games, 23.1% are negative. That’s 3.4 times the normal rate.

When AI is the product, players judge the game instead. Games like AI Roguelite, AI2U and Whispers from the Star are built on AI. On those games, reviews that mention AI are 26.3% negative. Across all their reviews it’s 23.1%, close enough to call even.

Games with no AI almost never get AI reviews. Across 99,986 reviews of hits like Blue Prince, Hades II and PEAK, only 0.14% mention generative AI. That’s about one review in 700.

AI complaints also carry more weight. Negative reviews that mention AI earned a median of 4 “helpful” votes. Other negative reviews earned 1. Steam shows the most helpful reviews by default, so AI complaints are more likely to sit where the next buyer looks.

Most critics still play. Players who complain about AI wrote their review after a median of 11.3 hours of play. Only 18% wrote it inside Steam’s 2-hour refund window. And in Steam reviews, “wait for a sale” comes up almost as often as “I quit” (135 mentions against 160).

So the typical punishment is a thumbs-down that warns the next buyer. Only 3.2% of these negative reviews carry Steam’s refunded flag.

Case studies

In each of these four stories, what mattered was when players found the AI and what the studio did next.

James Pond Legacy. Players spotted AI-looking art in the trailer and character work. The original creator, Chris Sorrell, said he hoped they “choke on an AI-generated fishbone.” Publisher System 3 denied using generative AI, blamed its developer’s assurances, and changed a caption from “3D Algorithm” to “3D Render.” Its boss Mark Cale admitted the controversy “has damaged confidence in System 3.” (Time Extension)

Vapor World: Over The Mind. The director swapped two cutscenes for AI video just before launch. Players noticed on day one. He posted an apology on Steam: “Using AI was entirely my own fault, and I am sorry.” The same day, a hotfix removed every AI cutscene. Its Steam rating sits at Mixed, and AI comes up in 48% of its English reviews.

Larian. In December 2025, CEO Swen Vincke said Larian used AI to explore ideas and write placeholder text for its next Divinity game. On 17 December, 22.5% of the Baldur’s Gate 3 reviews in our sample mentioned AI. Within weeks he reversed course and said “there is not going to be any GenAI art in Divinity.” (VGC) BG3 stayed overwhelmingly positive.

Sandfall and Clair Obscur: Expedition 33. AI placeholder textures slipped into the released game. Director Guillaume Broche said they were taken out “as soon as we saw it” and promised “everything will be made by humans from us” (Push Square).

The bigger problem was what Sandfall had said earlier. It had told the Indie Game Awards no generative AI was used, so when the placeholders came out, the awards withdrew its Debut Game and Game of the Year wins. AI mentions in its reviews peaked at 12% of our daily sample, then dropped back under 3% within about ten days. The game still sold more than 8 million copies.

Party Animals shows how bad it can get. In May 2026, its developer announced a contest that required AI video. In our data, the game’s English reviews jumped from 159 in the second half of April to 2,132 in May. Of those, 91% were negative and 52% named AI. The developer cancelled the contest after 57.3% of players voted to end it.

Big games survive this. ARC Raiders used text-to-speech voices and sold 14 million copies. Crimson Desert’s own Steam page says it used generative AI for some 2D props, and it sold 2 million in a day. An indie launch has no cushion like that.

What players object to and what they ignore

Players object to the AI they can see.

Among negative Steam reviews that mention AI and name what it was used for, visual art comes up in 49.1%. Writing and text appear in 26.8%, voice in 21.6%. Code appears in 2.4%.

The riskiest place for AI is your store page. When a review names AI in store or marketing images, 92% are thumbs-down. Cutscenes come in at 78% and in-game art at 66%.

Surveys agree. Quantic Foundry found gamers most negative about AI artwork, music and dialogue, and least negative about AI for dynamic difficulty. In GameDiscoverCo’s survey, coding tools were the most accepted use.

Players also told us how they catch it. The most cited clue in our data is the disclosure label itself, with 4,019 mentions. Then hands and fingers (2,938) and that glossy “AI look” (1,092). So if you use AI where players look, assume someone will check.

Is AI placeholder art okay?

Both sides of this argument have a point.

The case for it is simple. A placeholder lets you test a level before you pay an artist. And players in GameDiscoverCo’s survey named prototyping and placeholders as the second most acceptable use of AI.

The case against it is that placeholders do ship. Clair Obscur proves it. And on The Alters, where AI text was found before it was disclosed, 69% of reviews that mention AI are negative. The game’s normal rate is 11%.

Our rule:

1. Mark every placeholder in the build itself. A visible “TEMP” stamp works.
2. Keep a list of every AI asset and who will replace it.
3. Never put a placeholder on your store page, trailer or capsule.
4. Check the list before launch. Disclose anything that stays.

If you need art you can actually ship, start with our guide to AI pixel art generators for 2D indie games and read the licence terms before you commit.

What you must disclose

Steam. Valve’s content survey covers AI content that “ships with your game, and is consumed by players,” like artwork, sound, narrative and localization. The current Steamworks text says “efficiency gains through the use of these tools is not the focus.” So code assistants don’t need a label. Content generated live while the game runs needs a description of your guardrails. Players see your answer in an “AI Generated Content Disclosure” box on the store page.

Our Steam AI disclosure guide covers what to declare and what the label costs you.

itch.io. Since November 2024, every project page has a generative AI disclosure field. Answer yes and your page gets the AI Generated tag, plus sub-tags for graphics, sound, text and code. Answer no and you get the No AI tag. It’s mandatory for asset pages. Untagged AI assets drop out of browse.

Some devs use the disclosure box to say what they didn’t use, and you should copy them. AI2U’s Steam disclosure reads “None of the art assets in the game are AI-generated.” Only 17% of Steam fans believe developers fully disclose, so saying it plainly helps.

Game jam AI rules

Jams don’t agree, so read the rules page every time. Most fall into one of three types.

Global Game Jam goes further and allows AI with no restrictions. Its own survey of 3,578 jammers found 18% of teams used AI.

What if you’re falsely accused of using AI?

It happens, and it costs real studios. Shrine’s Legacy was review-bombed as “100% AI generated.” The team said they “only worked with real human artists on everything,” and the reviews recovered (Vice). The team behind Schrodinger’s Cat Burglar changed its capsule art because people kept calling it AI. It wasn’t. Axion 1986 says it lost press coverage over a trailer it made by hand (Creative Bloq).

You can’t stop the accusation, but you can make proof easy. Keep this ready before launch.

1. Layered source files: PSD, Krita or Blender files with their history.
2. A timelapse. Record your screen while you paint. The Little Droid team answered its accusers with a video showing the art being made.
3. Dated sketches, thumbnails and roughs.
4. A public devlog with work-in-progress images, posted as you go. Dates on the internet are hard to fake.
5. Credits that name your artists and link their portfolios.
6. Your AI policy on the store page, with a way for people to ask.

A safe-use framework

Use this ladder from safest to riskiest. Each step up raises the chance that players notice and care.

1. Code, QA and tools. 2.4% of AI complaints. Steam doesn’t ask about it. See our list of free AI tools for indie game developers.
2. Placeholders that never ship. Accepted by many players, if you follow the rule above.
3. Translation. Named in 3.1% of AI complaints, but Steam does require disclosure.
4. Writing and dialogue. Named in 26.8% of AI complaints.
5. Voice. Named in 21.6%. ARC Raiders survived it, and its CEO still said “a real professional actor is better than AI” (Engadget).
6. In-game art. Named in 49.1%, the biggest single target.
7. Cutscenes and store art. 78% and 92% negative when named. Vapor World pulled its AI cutscenes on launch day.

The higher you go, the more you need disclosure, a plan to replace, and proof. For the full tool list, see our best AI tools for indie game developers.

FAQ

How we did this research

We collected public comments on 5 and 6 October 2026 from Steam’s public review API, the Arctic Shift Reddit archive and 48 YouTube videos about AI in games. We flagged generative AI mentions with transparent keyword rules and hand-checked a random sample of 371. Every number here shows an association, not a cause. Commenters chose to write, so this isn’t a random sample of all gamers.

How we use AI on this site: We used Claude to write the collection scripts and to help sort and check the comments. Every statistic in this article was checked against its original source before publishing.

I picked 5 tools that animate a character and export a sheet. PixelLab, SpriteCook, Ludo, AutoSprite and Retro Diffusion. Each one solves a different problem, so the best one depends on what you already have and what you need out of it.

How I made this page. I compared the 5 from their own product pages, docs, pricing pages and API examples. I have not run the benchmark yet. That comes next, and the full test plan is further down so you can check my work when the results go up.

No tool on this page pays me.

Which AI sprite sheet generator should you use?

Short version, by job.

If you search “AI sprite sheet generator”, almost every result is a tool selling itself. That’s fine for a demo. It doesn’t tell you how many tries a walk cycle takes or how long the cleanup is.

So read this as the map. The test results will be the verdict.

AI sprite sheet generators compared

This is what each vendor documents. Prices change a lot in this category, so check the live checkout before you pay.

Three things jump out.

Only AutoSprite and Ludo export JSON next to the PNG. If you want the engine to read frame timing instead of typing it in, that matters.

Only Retro Diffusion documents palette input. If your game has a fixed palette, that’s the feature that stops colors from drifting.

And the billing models are all different. Monthly credits, yearly billing, one-time credits and per-call API pricing. A cheap sticker price tells you very little until you know how many credits one animation eats.

The 5 best AI sprite sheet generators

PixelLab: best for pixel art control

PixelLab is the one I’d look at first if you care about the pixels themselves. It does text-driven animation and skeleton-based animation, so you can pose the character instead of hoping the prompt lands. It also makes 4- and 8-direction views, generates from a reference image and has inpainting for fixing one part of a frame. PixelLab

It’s pixel art only. If you want HD or painted sprites, look elsewhere.

Pricing looks confusing until you read the small print. Pixel Apprentice is $12/month, Pixel Artisan is $24/month and Pixel Architect is $50/month. The first two get cheaper the longer you stay. Apprentice drops from $12 to $10, then $9.50, then $9.

That’s why SpriteCook’s comparison says PixelLab starts at $9. Both numbers are true, just not in the same month.

The free trial needs no card, and paid plans include commercial use. Some PixelLab tools use more than one generation per image, so check what an animation costs in your plan. PixelLab pricing

What I’ll test: whether a small asymmetric detail like a shoulder pad survives every frame, and whether idle and walk line up when you switch between them. Feature depth doesn’t prove the first output is the best one.

Skip it if you want HD art or you don’t want to touch an editor. If you’re deciding between PixelLab and a manual workflow, read PixelLab vs Aseprite.

SpriteCook: best for a full moveset with no learning curve

On paper, SpriteCook is the shortest path from nothing to a character that moves. The character creator has presets for idle, walk, attack and run. There’s also an animator that takes an image you already have. Exports are transparent PNGs and sprite sheets, and it offers API and MCP access if you work with Claude or Cursor. SpriteCook

It does pixel art and more detailed HD art in one tool. That’s the main thing it has over PixelLab.

Starter is $8/month plus VAT for 800 credits. You get 40 free credits every 30 days. SpriteCook lists about 20 credits per animation, so 800 credits is roughly 40 animations if nothing fails. Retries eat the same credits, so treat 40 as the ceiling. SpriteCook pricing

What I’ll test: whether the output sits on a real pixel grid, whether frames stay registered to the same spot and what the files contain. I’ll show the untouched output next to the cleaned one, because “game-ready” means nothing until it plays in an engine.

Skip it if you need fine control over each pose.

Ludo: best for directing motion and controlling exports

Ludo gives you the most ways to tell the animation what to do. You can write a motion prompt, set up to 3 keyframes, upload a reference video for the motion or use a preset. Ludo’s walk cycle page lists 30 walk presets. Ludo sprite generator

Exports are PNG sheets, JSON and individual frames. The Animation Pack can normalize sizes and align characters to the ground, which saves you from characters that bob or shrink between animations.

Indie is $15/month and Pro is $35/month when you pay for the year. That’s $180 or $420 up front. Ludo says yearly billing saves up to 35%, so month to month costs more. There’s a 30-credit trial on the feature page. Ludo pricing

Ludo publishes its own “best AI sprite generators” list and puts itself first. They say so on the page, which is fair. It’s still a vendor ranking.

What I’ll test: the loop seam on the walk, whether the attack has a clear windup, hit and recovery, and whether normalization keeps the body proportions. Ludo works in square grids from 4 to 64 frames, so I’ll report native frame counts and any resampling.

Skip it if you don’t want to pay for a year up front.

AutoSprite: best for animating a character you already have

AutoSprite starts from one image and turns it into a set. Idle, walk, run, jump and attack. You get PNG sheets plus JSON with positions and timing, and you can edit frames after. It also does 8-direction isometric animation. AutoSprite FAQ

It lists export support for Unity, Unreal, Godot, GameMaker, Phaser and RPG Maker.

Starter is $12/month for 500 credits and Pro is $29/month for 1,500. New accounts get 15 credits plus daily login bonuses. There’s a cheap 5-credit Turbo mode and more expensive generation modes above it, so the real cost depends on which mode you run. AutoSprite pricing

One catch for pixel art. The FAQ recommends source images between 512 and 1024 px. A 64×64 sprite is way smaller than that. My plan is to enlarge it with nearest-neighbor scaling and say so. Then I check if the export still looks like pixel art.

The pricing page and the FAQ also describe API and MCP access a bit differently. Check in the app which plan you need.

Skip it if you start from text and have no character art yet.

Retro Diffusion: best for real pixel art and pay-per-use

Retro Diffusion is built only for pixel art. It has dedicated styles for walking, idle and attack animations. The official API examples show palette input, transparent output and a full PNG sprite sheet from one request. Retro Diffusion API examples

There’s no subscription. The website gives 50 starter credits and the credits don’t expire. On the API side, the examples list $0.14 for a standard animation and $0.25 for custom action or subtle motion. Website credits and API dollars are two separate things, so don’t mix them up. Retro Diffusion credits

If you’ve used Sorceress Quick Sprites, Sorceress says it runs on Retro Diffusion. Same model, different interface.

What I’ll test: which actions it covers, the source size limits per model and how much prep the export needs before it plays.

Skip it if you want a big button that makes a whole moveset at once. I compared it head to head in Retro Diffusion vs PixelLab.

Other AI sprite tools worth a look

Spritesheets.ai would be my sixth pick. It targets exactly this search and advertises JSON and XML atlas files with pivot points. Its Lite plan showed 1,000 tokens in one place and 1,500 in another, so ask before you buy. Spritesheets.ai pricing

Scenario and Layer are bigger production platforms with sprite workflows. They make more sense for a studio than for one person shipping a small game.

AI walk cycle generators: what a good walk looks like

Walk cycles are the first animation almost every game needs. Every moving character has one, and it’s where AI output breaks in the most visible way.

A usable walk cycle does 4 things. The feet don’t slide on the ground. The last frame flows back into the first without a jump. The character stays in the same spot in every frame. And the gait reads as a walk at game size, not only zoomed in.

SpriteCook has a dedicated walk cycle generator. Ludo has the 30 walk presets. Retro Diffusion has a walking style. AutoSprite and PixelLab make walks as part of a full set.

Idle is easier. The feet stay planted and only the chest moves. If a tool can’t hold the feet still during idle, it won’t hold them during a walk either.

Attack is the hardest. You need a windup, a clear hit frame and a recovery, and the weapon has to stay the same shape the whole time. This is where I expect the most failures.

Pixel art animation with AI: real pixels vs fake pixels

A lot of AI output looks like pixel art from far away. Zoom in and the pixels are different sizes, the edges are blurry and there are 40 shades of the same red.

Those are pseudo-pixels. Your engine will show them exactly as they are, and they look wrong next to handmade sprites.

Three checks take 1 minute. Zoom to 800% and see if every pixel is the same size. Count the colors against your palette. And put the sheet on a bright pink background to find edge halos and fake transparency.

PixelLab and Retro Diffusion are the two built around native pixel art. Retro Diffusion also takes a palette. That doesn’t prove they need less cleanup. It just means they’re built for the problem.

SpriteCook vs PixelLab: which one should you pay for?

Search “SpriteCook vs PixelLab” and the top result is written by SpriteCook. So here’s the neutral version.

Pick SpriteCook if you want presets, a saved library of your assets and both pixel and HD art in one place. It’s cheaper to start at $8/month and it’s built for beginners.

Pick PixelLab if you want skeleton control, 8 directions and inpainting to fix single frames. It’s pixel art only, and it pairs with Aseprite if you like to edit by hand.

Storage is the one difference people miss. PixelLab’s own FAQ says it doesn’t store the images you generate or upload. That’s good for privacy, but you have to save everything yourself. SpriteCook keeps your assets in your account. PixelLab terms

The same-character test will decide this one properly.

What does an AI sprite animation really cost?

The sticker price is the wrong number. The real number is what you spend per animation you actually keep.

Here’s the math from what vendors publish, before any failed attempts.

Now add retries. If a walk cycle takes 3 tries to get right, the SpriteCook number triples. If it never passes, the cost per usable animation isn’t cheap. It doesn’t exist.

That’s the number I’ll publish after testing. Total spend including failures, divided by animations that passed. Plus cleanup minutes.

Can you test them all for free?

Mostly, yes. With the free allowances you can run one character through all 5 this weekend.

SpriteCook gives 40 free credits, which is about 2 animations. Ludo has a 30-credit trial. AutoSprite gives 15 credits plus a daily bonus. Retro Diffusion gives 50 starter credits. PixelLab has a free trial with no card.

Use the same character in all of them. Do one walk cycle each. You’ll learn more in 2 hours than from any comparison page, this one included.

Free also doesn’t always mean commercial. Check each tool’s terms for what your plan allows, and remember that a vendor’s permission isn’t a legal guarantee. If you ship on Steam, read the Steam AI disclosure guide too.

Does it import into Godot and Unity?

A sheet that doesn’t import cleanly is just a picture. Before you open the engine, check that every frame is the same size, the order is right and the background is actually transparent.

In Godot 4, add an AnimatedSprite2D and make a new SpriteFrames resource. Click the button to add frames from a sprite sheet and set the horizontal and vertical frame counts. Set texture filtering to Nearest or your pixel art will blur.

In Unity, set Texture Type to Sprite (2D and UI) and Sprite Mode to Multiple. Set Filter Mode to Point and Compression to None. Then slice it in the Sprite Editor by cell size or cell count.

If the tool gives you JSON, check that the frame rectangles match the PNG before you write any import code.

The full step-by-step setup is in my AI sprite generator guide for platformers, with prompt templates and a checklist for the PNG.

Why AI sprites jitter and how to fix it

Jitter is usually one of two problems. And they need different fixes.

The first is registration. The character is fine, but it moves around inside the frame. The feet land 2 pixels higher in frame 3 than in frame 2, so the whole sprite bounces. Fix it by setting the pivot at the feet and padding every frame to the same canvas. Aseprite or Pixelorama can align frames by hand in a few minutes.

The second is deformation. The character itself changes. The sword gets longer, the scarf changes color, the face shifts. No alignment fixes that. Regenerate the bad frame, inpaint it if the tool can, or cut the frame count so there are fewer chances to break.

Palette drift and fake pixels are a third, smaller problem. Reduce the colors back to your source palette and scale down with nearest-neighbor.

Onion skinning shows you which one you have in seconds. If the outline stays the same shape but moves, it’s registration. If the shape changes, it’s deformation.

The test I’m running next

A comparison without outputs is only half the job. So here’s exactly how I’ll test the 5, published before I have results.

One character. A 64×64 pixel art swordswoman with a navy tunic, red scarf, silver sword, gold buckle and one shoulder pad on one side only. Side view, facing right. The same file goes into every tool, and I’ll say whenever a tool forced me to resize it.

Three actions. Idle with breathing and planted feet. One walk cycle in place. One sword slash with windup, hit and recovery. 8 frames where the tool allows it.

Three attempts per action per tool. That’s 45 animations, and all 45 get published, failures included.

Each one gets scored out of 100.

A pass means the character is recognizable, the action reads, nothing is cropped, the frames are in order, the transparency works and it plays in Godot. I allow 10 minutes of cleanup, max, and report before and after separately.

The source character, palette, native outputs and a results CSV will be downloadable here. Then you can run the same test yourself and argue with my scores.

Want a ping when the results go up? Subscribe to the comments at the bottom of this page.

FAQ

Can ChatGPT make sprite sheets?

ChatGPT can draw an image that looks like a sprite sheet. It doesn’t give you an even frame grid, a fixed pivot, JSON timing or a guarantee the character stays the same across frames. For a prototype it’s fine. For a game you’d slice and fix it by hand, so a dedicated tool is usually faster.

Is there a free AI sprite sheet generator?

All 5 have a free way in. SpriteCook gives 40 credits every 30 days, Ludo has a 30-credit trial, AutoSprite gives 15 credits plus daily bonuses, Retro Diffusion gives 50 starter credits and PixelLab has a free trial with no card. Free plans may limit exports or commercial use, so read the terms.

Can AI animate a sprite I already drew?

Yes. SpriteCook’s animator, AutoSprite and Ludo all take an existing image. AutoSprite recommends 512 to 1024 px sources, so small pixel art may need a clean nearest-neighbor upscale first.

Can AI make 8-direction sprites?

PixelLab documents 4- and 8-direction views and AutoSprite documents 8-direction isometric animation. I haven’t tested either for 8 directions yet, so treat those as vendor claims for now.

Can I use AI sprites in a commercial game?

Usually on paid plans, but it depends on the tool and the plan. Read the terms for the plan you actually buy. On Steam you also have to disclose AI-generated content.

Sources and updates

Everything above comes from vendor pages. That covers product pages, docs, pricing pages and API examples. Vendor docs prove what a tool claims to do, not how well it does it. The test results will replace the “What I’ll test” notes when they’re done.

If you want more tools for static sprites, tiles and backgrounds, the bigger list is in best AI pixel art generators for 2D indie games. If you still need the base character, start with the AI character generator guide.

Which tool are you using for walk cycles right now?

The short answer: on Unity 6 or newer, use Unity’s official MCP server through the Unity CLI. It’s free, and it replaces the older server inside the AI Assistant package, which Unity has deprecated. On Unity 2021.3 or 2022.3, use CoplayDev’s MCP for Unity. And before you debug anything, check the prerequisites that break most setups, like a missing uv install that kills the server without a useful error.

Below: exact setup commands for all three servers worth using, plus fixes by symptom for when it still won’t connect.

Commands, versions and pricing checked against Unity’s docs and each project’s GitHub repo.

Which Unity MCP server should you use?

A Unity MCP server is a bridge. One half runs inside the Unity Editor. The other half speaks the Model Context Protocol to Claude Code, so Claude can read your real scene hierarchy, create GameObjects, edit C# and read the Console instead of guessing. Three servers matter right now:

*Versions and star counts taken from the GitHub releases pages. These packages ship often, so check the release you install.

Sources: Unity AI FAQ and pricing, Unity MCP docs, CoplayDev/unity-mcp and IvanMurzak/Unity-MCP.

Is Unity’s official MCP server free now?

Yes. If you read an older guide, this is the part that changed. When Unity AI entered open beta in May 2026, Unity staff confirmed on the forums that “a subscription is required for an MCP connection”, so Personal users needed the $10/month Unity AI plan just to connect Claude Code. At Unite Seoul in July 2026, Unity announced “a free-to-use MCP” alongside its new Unity CLI. Unity’s AI FAQ now says the MCP server “is free, with no concurrency limits” and doesn’t consume Unity credits. The same goes for the AI Gateway, which runs third-party agents inside the Editor.

What still costs money is Unity’s own in-Editor AI Assistant: a 14-day trial for Personal users, then $10/month for 1,000 credits, or included with Pro, Enterprise and Industry. You don’t need it to use Claude Code over MCP. You do still need your own Claude plan.

Two things the table can’t show

• Don’t stack routes in one project. On Unity 6.3+, the AI Assistant package and MCP for Unity ship conflicting versions of System.Collections.Immutable, and the project stops compiling. Pick one server per project.
• Skills are not MCP. On 9 September 2026, Unity released an official Unity plugin for Claude Code with 29 skills (UI Toolkit, 2D and tilemaps, localization, multiplayer, Shader Graph and more). Skills teach Claude how current Unity works. MCP is what lets it act on your open Editor. Use both.

Before you start: the 3 things that break setup

Most failed setups are missing a prerequisite. Check these first so you’re not debugging the wrong layer later.

1. Claude Code is installed and on your PATH.

Terminal

claude --version

If the command isn’t found, install Claude Code with the native installer (irm https://claude.ai/install.ps1 | iex in PowerShell, or curl -fsSL https://claude.ai/install.sh | bash on macOS/Linux). Restart your terminal and run claude doctor. Every route below ends with Claude Code launching an MCP server, so nothing works without the CLI. On macOS, apps launched from Finder don’t always inherit your shell PATH, which is why Unity-side configurators sometimes report “Claude not found” even though it works in Terminal.

2. The runtime your server needs actually exists. For MCP for Unity, that means Python 3.10+ and uv:

Terminal

python --version
uv --version

If uv is missing, the server can never start. Claude Code reports a closed connection and gives no useful hint why. It’s the Unity version of the Node.js problem in our guide to using AI with Godot 4. The official route and Unity-MCP don’t need an extra runtime, but Unity-MCP fails if your project path contains spaces.

3. You have a git commit to go back to. MCP gives Claude write access to your project. Commit before your first session:

Terminal

git add -A
git commit -m "checkpoint: before Claude session"

You’ll want that commit. An agent that “tidies up” a scene can remove a component you needed, and Unity’s undo won’t always save you. If the project isn’t under version control yet, first set Asset Serialization Mode to Force Text and Version Control Mode to Visible Meta Files (Edit → Project Settings → Editor). With those settings, scene and prefab changes show up as readable YAML diffs instead of binary blobs.

Route 1: Unity’s official MCP server with Claude Code

Unity’s official server gives Claude Code live access to the scene hierarchy, GameObjects, component values, Console output and build settings. It requires Unity 6 (6000.0) or later and isn’t backwards compatible. Use the Unity CLI, which ships its own MCP server built on the Unity Pipeline package. Unity has deprecated the MCP server inside the AI Assistant package, so the package route below is only for projects that already depend on it.

Option A: the Unity CLI (recommended)

The Unity CLI launched at Unite Seoul. It’s a terminal tool for the Editor, Hub, builds and cloud services, and it includes an MCP server. It’s still on a beta channel, so try it on a branch before your main project. Install:

Terminal

# macOS / Linux
curl -fsSL https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.sh | UNITY_CLI_CHANNEL=beta bash

# Windows (PowerShell)
$env:UNITY_CLI_CHANNEL='beta'; irm https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.ps1 | iex

Open a new terminal and confirm unity --version works. Then install the Pipeline package, which the CLI’s MCP server is built on, and register the server with Claude Code:

Terminal

unity pipeline install            # Unity 6.0 LTS or newer
unity mcp configure --list        # see supported clients and their names
unity mcp configure claude        # points Claude Code at the CLI's MCP server
claude mcp list                   # confirm it's there

Unity’s docs use claude as the client name. If --list shows a different name in your CLI build, use that one. The command updates Claude Code’s MCP config for you. If Claude can run shell commands, unity command and unity eval drive the Editor directly, and Unity says they’re faster and use fewer tokens than MCP. Run unity skill install with your agent’s name to add Unity’s agent skills. Keep the Editor open while you work, because the server talks to a live Editor session. The CLI changes quickly during beta, so if a subcommand has moved, unity mcp --help shows the current syntax.

Option B (deprecated): the AI Assistant package

Unity has deprecated this server. Use it only if your project already depends on it. To move, install the Unity CLI, run unity pipeline install, then run unity mcp configure claude. Third-party servers like MCP for Unity and Unity-MCP are not affected.

Step 1: Install the package and check the bridge.

1. In Window → Package Manager, install the AI Assistant package (com.unity.ai.assistant).
2. Open Edit → Project Settings → AI → Unity MCP.
3. Confirm Unity Bridge shows a green Running indicator. It starts when the Editor loads. If it says Stopped, clear any Console compile errors and click Start.

When the Editor starts, Unity installs a small relay binary to ~/.unity/relay/ (%USERPROFILE%\.unity\relay\ on Windows). That relay is the process Claude Code launches.

Step 2: Register Claude Code. In the same settings page, expand Integrations, select Claude Code and click Configure.

If Configure fails, or you want control over scope, register the relay yourself. The --mcp flag is mandatory, and the -- separator makes sure Claude Code passes it through to the relay:

Terminal

# Windows (PowerShell)
claude mcp add --scope user unity-mcp -- "$env:USERPROFILE\.unity\relay\relay_win.exe" --mcp

# macOS (Apple Silicon)
claude mcp add --scope user unity-mcp -- ~/.unity/relay/relay_mac_arm64.app/Contents/MacOS/relay_mac_arm64 --mcp

# macOS (Intel)
claude mcp add --scope user unity-mcp -- ~/.unity/relay/relay_mac_x64.app/Contents/MacOS/relay_mac_x64 --mcp

# Linux
claude mcp add --scope user unity-mcp -- ~/.unity/relay/relay_linux --mcp

If you have more than one Editor open, append --project-path "C:/Path/To/Project" after --mcp so the relay targets the right one.

Step 3: Approve the pending connection. This is the step people miss. Start Claude Code in your project folder and ask it anything that touches Unity. The first time, Unity doesn’t let it straight in. It holds the request as a Pending Connection, with no pop-up to tell you.

1. Go back to Edit → Project Settings → AI → Unity MCP.
2. Under Pending Connections, check that the client is Claude Code.
3. Click Accept. Unity remembers the approval and reconnects automatically from then on.

Until you accept, Claude can see that the server exists but can’t use it, which looks exactly like a broken setup. Don’t click Deny or Revoke “just to reset it”. Forum users report that a stored rejection leaves the connection stuck until they clear cached state (see the fixes below). Connections made through Unity’s AI Gateway are approved automatically.

Optional: add Unity’s official skills

To give Claude current Unity know-how on top of Editor access, install Unity’s plugin from inside Claude Code:

Claude Code session

/plugin marketplace add Unity-Technologies/unity-agent-plugin
/plugin install unity@unity-agent-plugin

Type /unity: to see the skills it added. If they don’t appear, Unity’s plugin docs suggest clearing ~/.claude/plugins/cache and reinstalling.

Route 2: MCP for Unity (Coplay) with Claude Code

MCP for Unity from CoplayDev is the community favourite. It’s MIT-licensed, supports Unity 2021.3 LTS through 6.x, and works with Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Gemini CLI and other MCP clients. It exposes 47 tool entry points covering scenes, GameObjects, scripts, assets, tests, profiling and builds. It uses a Python server launched through uv, which talks to Claude Code over HTTP on localhost:8080 by default.

Step 1: Install uv

Terminal

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# then, in a NEW terminal
uv --version

Step 2: Add the package from a pinned git URL

In Unity, open Window → Package Manager, click + and choose Add package from git URL. The README’s default URL ends in #main, and #main moves: a Monday update can break a Friday setup. Pin a release tag for real projects:

Package URL

https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#v10.2.0

Swap in whatever tag is current on the releases page. Git must be installed for git URLs to work. If Unity says “Error when executing git command”, install Git, restart Unity and, if needed, run git config --global --add safe.directory "C:/Path/To/Project". If you prefer registries, openupm add com.coplaydev.unity-mcp also works.

Step 3: Let it configure Claude Code

A setup wizard opens after import and checks for Python and uv. Then open Window → MCP for Unity and click Configure All Detected Clients, or tick Claude Code and choose Configure Selected. Restart Claude Code afterwards.

Step 4 (fallback): add the server by hand

If the window can’t find your claude binary, which is common with NVM installs and on macOS, register the HTTP endpoint yourself:

Terminal

claude mcp add --transport http --scope user UnityMCP http://localhost:8080/mcp

You can also point the window at the binary with Choose Claude Location. For NVM, that’s typically ~/.nvm/versions/node/<version>/bin/claude. Claude Desktop only supports stdio, so the configurator writes a different entry for it. If you ever switch transports, restart Claude Code.

Don’t mix this up with Coplay’s other product. Coplay also makes its own Unity AI assistant, and its docs describe a separate server called coplay-mcp-server (Python 3.11+), installed with uvx … coplay-mcp-server@latest. That command connects Claude Code to the Coplay assistant, not to the free MCP for Unity package. Plenty of setups fail because someone followed one product’s instructions for the other.

Route 3: Unity-MCP (IvanMurzak), free and open source

IvanMurzak’s Unity-MCP connects AI clients to both the Unity Editor and a running game. Its in-Editor window is called AI Game Developer, and it’s Apache-2.0 licensed. Your client talks to a .NET MCP server over stdio or streamable HTTP, and that server talks to Unity. The server is a self-contained binary, so you don’t need Python or Node.

Pick this one if:

• you’re on Unity 2022.3, so the official server is closed to you, and you want the most tools. It has 70+, including tests-run for EditMode and PlayMode tests, plus profiler control
• you don’t want a Python toolchain on your machine
• you want AI inside the shipped game, not just the Editor. It’s the only one of the three with a runtime API, for things like LLM-driven NPCs or in-game debugging

Setup:

1. Install the .unitypackage installer from the GitHub releases page, or run openupm add com.ivanmurzak.unity.mcp.
2. Wait for the plugin to download its server binary to Library/mcp-server/.
3. Open Window → AI Game Developer and use the Claude Code configurator. It has built-in configurators for 14 clients.

To register it by hand, copy the command for your platform from the README and pass it to Claude Code. Use the port shown in the AI Game Developer window:

Terminal

# Windows x64 example
claude mcp add ai-game-developer -- "C:/Path/To/Project/Library/mcp-server/win-x64/gamedev-mcp-server.exe" port=<port> client-transport=stdio

Two gotchas are specific to this route. The project path cannot contain spaces. And ports are derived from your project path, in the 20000–29999 range, so two projects get two different ports. That’s handy for multi-project work, but it means you can’t copy one project’s config to another.

Verify the connection with a read-only prompt

Don’t start with “build me a player controller”. Start with something that can’t break anything.

1. In a terminal, run claude mcp list. Your Unity server should be listed and reported as connected.
2. Open Claude Code in your project folder and type /mcp. The Unity server should show a tool count greater than zero.
3. Run a read-only prompt:

Prompt

List the full scene hierarchy of the open scene, including inactive
objects. Don't change anything.

If Claude returns your real GameObjects with the names you gave them, the connection is live. If it invents a hierarchy (“Main Camera, Directional Light, Player…”) for a scene that doesn’t contain those objects, it isn’t reading Unity at all. It’s guessing. Go to the fixes section.

Unity’s docs suggest a second check for the official route: “Read the Unity console messages and summarize any warnings or errors.” A real answer quotes your actual Console.

Your first 5 prompts (safe → powerful)

Work up the ladder. Each step tests one more permission before you trust the next, so if something’s wrong you find out on a harmless prompt.

1. Read

Prompt

Read the Unity Console and summarise any errors or warnings. Then
describe the components on the GameObject named "Player".
Don't modify anything.

2. Create

Prompt

Create an empty GameObject named "Enemy" at position (5, 0, 0).
Don't modify any existing objects.

3. Modify

Prompt

Add a Rigidbody to "Enemy". Set mass to 2 and freeze rotation on X and Z.
Tell me the exact values you set.

4. Write code

Prompt

Create Assets/Scripts/EnemyChase.cs. Move toward the GameObject tagged
"Player" at speed 3 using Rigidbody.MovePosition in FixedUpdate.
Wait for compilation, then read the Console and fix any errors
before attaching it to "Enemy".

The last line matters most. An agent that reads the Console fixes its own compile errors. One that doesn’t will announce success on code that doesn’t build. Waiting for compilation also stops the agent from calling the next tool while Unity is still reloading the domain, which fails and gets misread as a broken script.

5. Verify with tests

Prompt

Create an EditMode test in Assets/Tests/EditMode that checks EnemyChase
exposes a public speed field greater than zero. Run the EditMode tests
and report pass/fail with the output of any failures.

Prompt 5 needs a server with a test tool. MCP for Unity and Unity-MCP have one. On the official route, check your tools list first.

Unity MCP not connecting? Fixes by symptom

These come from the Unity Discussions AI Assistant threads, the CoplayDev and IvanMurzak troubleshooting docs, and Unity’s own troubleshooting page. Find your symptom and work through the fixes in order. The first fix listed is the most common cause.

Claude only appears in “Other Connections”, never “Connected Clients”

Route: official (package). This is the symptom in the “Can’t connect Claude to the MCP” thread, reported on Windows 11 and macOS between May and July 2026. Work through these in order:

1. Approve the pending connection (Route 1, Option B, Step 3). An unapproved client looks exactly like this.
2. Change the AI Assistant package version. Thread participants reported 2.7.0-pre.3, 2.9.0-pre.2, 2.12.0-pre.1 and 2.13.0-pre.2 as broken, and 2.6.0-pre.1 and 2.17.0-pre.1 as working. Not everyone was fixed by switching. In Package Manager, move to a version reported as working, restart the Editor and re-approve.
3. Clear a stored rejection. If you ever clicked Deny or Revoke, that state persists. Close Unity and any relay processes, delete the project’s Library/AI.MCP folder, then reopen and accept the new pending connection.
4. Close other connected clients. Package versions from the beta period allowed one direct connection at a time. Opening a second Claude Code session, or Cursor alongside it, dropped the first (see the “Connection revoked” thread). Unity now advertises no concurrency limits, but if you’re on an older package, close Claude Desktop, Cursor and other MCP clients and reconnect Claude Code alone.
5. Move to the Unity CLI route (Route 1, Option A). Unity has deprecated the package server, and the CLI bypasses its Project Settings approval flow entirely.

“Connection closed” or the server never starts

Claude Code launched the server and it died immediately. Check in this order:

• MCP for Unity: uv is missing or not on the PATH that Claude Code sees. Run uv --version in a fresh terminal. On Windows, if the WinGet install isn’t found, point the config at %LOCALAPPDATA%\Microsoft\WinGet\Links\uv.exe. Then use Window → MCP for Unity → Restart Server.
• Official (package, deprecated): the relay isn’t in ~/.unity/relay/. It only appears after the Editor has started at least once. Also check that your config includes --mcp. Restart the Editor to reinstall the relay, or use Locate Server in the Unity MCP settings.
• Official (CLI): unity isn’t on your PATH yet. Open a new terminal or refresh PATH after installing.
• Unity-MCP: the server binary didn’t download to Library/mcp-server/. Antivirus blocking and network failures are the usual causes, along with spaces in the project path. Its wiki’s “nuclear option” is to delete Library/mcp-server/, restart Unity and reconfigure.
• Port conflict (HTTP routes): something else already owns port 8080. Tailscale and local dev servers are common culprits. Check with netstat -ano | findstr :8080 (Windows) or lsof -i :8080 (macOS/Linux). Change the port in the MCP for Unity window, then re-register the new URL in Claude Code.
• Any route: did you restart Claude Code after changing config? Config is read at launch.

To see the real error, run claude mcp get <name> to show the exact command Claude Code launches, then run that command yourself in a terminal. Whatever it prints is your actual problem.

The tools list is empty

The server shows up, but /mcp reports zero tools, or the server isn’t listed at all.

1. Check it’s registered where you are. Run claude mcp list from the project folder. If your Unity server is missing, it was registered in a different scope or a different folder (see “Works in Claude Desktop, not in Claude Code” below).
2. Validate the JSON. A single trailing comma in .mcp.json silently breaks the whole file.
3. Clear Console compile errors. All three servers discover tools through Editor scripts, and Unity won’t load new Editor code while any script fails to compile.
4. Check tools are enabled. The official route has a Tools section in its settings, plus a Show Debug Logs option for discovery details. MCP for Unity has toggleable tool groups.
5. Restart the session. Claude Code loads the tool list when a session starts. Exit and relaunch claude after fixing the Unity side.
6. Check for the DLL conflict (Unity 6.3+). If the AI Assistant package and MCP for Unity are both installed, System.Collections.Immutable version errors block compilation. Remove one of them.

It connects, then drops after Play Mode or a recompile

Every script change and every Play Mode entry triggers a domain reload. Unity tears down and rebuilds all Editor C#, including the MCP bridge, so some disconnection is expected. Unity-MCP’s wiki calls it normal and reconnects automatically. It only becomes a problem when the bridge doesn’t come back.

• Quick fix: wait for compilation to finish, then retry the prompt. Most servers reconnect on their own.
• If it doesn’t reconnect: restart the bridge. On the deprecated package route, that’s Start in the Unity MCP settings. On MCP for Unity, it’s Restart Server. Then restart Claude Code.
• Prevention: put a “wait for compilation, then read the Console” rule in CLAUDE.md (below), and don’t ask for “write a script and immediately run it” in one breath on slow machines.
• Play Mode option: in Edit → Project Settings → Editor → Enter Play Mode Settings, you can skip the domain reload. Play Mode gets faster and the bridge survives, but static fields no longer reset between runs, so only do this if your code handles it.
• Unity 6.5 editor hang: if the Editor sits at around 100% CPU and the bridge never connects, Coplay’s troubleshooting guide traces it to pre-release AI packages (com.unity.ai.assistant, com.unity.ai.inference) livelocking the asset database. Remove them from Packages/manifest.json, delete packages-lock.json and clear Library/.

Works in Claude Desktop, not in Claude Code

They’re different clients with different config files. Configuring one does nothing for the other, and within Claude Code, scope decides where a server is visible:

The classic mistake is running claude mcp add from your home directory, then launching claude inside the Unity project, where the server doesn’t exist. Re-add it with --scope user, or add it from the project root. Only use --scope project if the whole team uses the same route, because relay paths are machine-specific.

WSL2: Claude Code in Linux, Unity on Windows

Stdio can’t cross that boundary. Either run Claude Code natively on Windows (simplest) or use MCP for Unity over HTTP. Coplay’s guide moves the port to 8090, forwards it with netsh interface portproxy, opens the firewall, then registers claude mcp add --transport http UnityMCP http://<windows-host-ip>:8090/mcp.

Keep Claude from wrecking your project

MCP is a write-access tool. Treat it like handing a keen junior developer your editor for an hour. Three rules hold up:

• Commit before, diff after. Every session. Run git diff --stat when Claude finishes. If a scene diff is bigger than you expected, revert it with git checkout -- Assets/Scenes/YourScene.unity and ask for the change through a script instead.
• Gate scene and prefab edits. Scripts are plain C# that diffs cleanly. Serialized scenes and prefabs are large YAML that nobody reviews well. Let Claude write code freely, and make it ask before it edits scenes.
• One task per prompt. “Refactor the inventory and fix the UI and add save/load” is how you lose an afternoon.

Put the rules where Claude will read them. Claude Code loads a CLAUDE.md file from your project root at the start of every session. Copy this and edit the first section:

CLAUDE.md

# CLAUDE.md: Unity project rules

## Project
- Unity [YOUR VERSION], [URP/HDRP/Built-in], [new Input System / old].
- Use only APIs available in this Unity version.
- Scripts live in Assets/Scripts/<Feature>/. Tests in Assets/Tests/EditMode.

## You MAY edit freely
- Assets/Scripts/**, Assets/Tests/**
- ScriptableObject assets you created in this session

## Ask before touching
- Any .unity scene or .prefab file (describe the change, wait for "yes")
- ProjectSettings/**, Packages/manifest.json
- Deleting or renaming ANY asset (breaks GUID references)

## Never touch
- Library/, Temp/, Logs/, UserSettings/
- .meta files by hand

## After every script change
1. Wait for Unity to finish compiling.
2. Read the Console. Fix errors before any other tool call.
3. Do not enter Play Mode unless asked.

## Code rules
- Rigidbody physics in FixedUpdate, never Update.
- No FindObjectOfType in Update loops.

## Before finishing
- Run EditMode tests (if a test tool is available) and report results.
- Summarise every file you changed.

Claude Code vs Unity AI Assistant: do you need both?

They overlap less than the names suggest. Unity’s AI Assistant lives inside the Editor, knows Unity’s own documentation and adds Unity-native generation features. It runs on Unity AI credits: $10/month for 1,000 on Personal after the trial, or included with Pro and Enterprise. Claude Code lives in your terminal and codebase, runs on your Claude plan, and is stronger at multi-file refactors, test suites and reasoning across the whole project.

Since the MCP server became free, you don’t need the Assistant subscription to connect Claude Code on Unity 6. The Unity CLI doesn’t need the package at all. If you keep the package for the Assistant itself, use version 2.13 or later, which fixes a conflict with the CLI. A practical split:

• Quick Editor questions and asset generation: the Assistant.
• Anything touching three or more scripts: Claude Code over MCP.

To compare other coding tools, see our guide to AI code assistants for Unity.

Versions this guide is based on

Unity MCP tooling changes almost weekly, so here’s exactly what the commands and menu paths above were checked against. If your version is newer and something doesn’t match, the linked docs are the source of truth.

FAQ

Where to start

• On Unity 6 or newer: use the official server through the Unity CLI. It’s in beta, so try it on a branch first. Unity has deprecated the older package route.
• On 2021.3 or 2022.3 LTS: use Coplay’s MCP for Unity, pinned to a release tag.
• If you don’t want Python on your machine, or you want AI in the shipped game: use IvanMurzak’s Unity-MCP.
• Stuck on “Other Connections”: move to the Unity CLI. If you must stay on the package, approve the connection first and change the package version second.

Whichever route you pick: commit before, read the diff after, and start every session with a read-only prompt.

Related guides:

• Claude game development guide: the full picture across Unity, Godot and Unreal
• Claude Code for game development: which engine Claude handles best, real projects and what they cost
• How to use AI with Godot 4: the Godot version of this setup
• Unreal Engine 5.8 MCP server guide: the Unreal version of this setup
• AI game prototyping tools
• How to vibe code a game

Every model learned from a decade of Godot 3 tutorials, and it can’t tell which era it’s quoting. The fix is in the prompt: state your exact version (Godot 4.7, GDScript), paste your scene tree, and tell it what NOT to use.

Below: that prompt in full, a Godot 3 to 4 translation table, and the four real ways to use AI with Godot: chat models, MCP servers, AI inside the editor, and AI inside your shipped game.

Every code sample was run on Godot 4.7.2-stable before publishing.

Which kind of “AI with Godot” do you actually mean?

The phrase covers four unrelated jobs. Pick your row before reading further.

That last row is the one people misfile most often. “Enemy AI” and “LLM” are different technologies solving different problems. A patrolling skeleton does not need a language model. More on that below.

Fix this first: the Godot 3 contamination problem

Before any tool, any plugin, any workflow — understand what the model is getting wrong, because it fails silently. The code looks right. It’s structured correctly. It just references an engine that no longer exists.

The translation table

These are the substitutions that account for most broken AI output in Godot 4.x. Keep this open while you review generated code.

If you see any left-column item in AI output, stop and re-prompt rather than patching by hand. One Godot 3 reference usually means the model has locked onto a Godot 3 mental model for the whole response, and the rest of the architecture will be subtly wrong too.

The prompt that prevents it

Four elements, every time. Skip any one and accuracy drops sharply.

Prompt

Godot 4.7, GDScript, static typing.

Scene tree:
Player (CharacterBody2D)
├── AnimatedSprite2D
├── CollisionShape2D
└── Camera2D

Write top-down 8-direction movement using Input.get_vector with the
default ui_* actions. Speed 220. Use @export for tunables and @onready
for node references. Do not use KinematicBody2D or move_and_slide with
arguments — this is Godot 4.

The explicit negative instruction at the end is not paranoia. It measurably reduces Godot 3 leakage, because it puts the deprecated identifier in the context window as something to avoid rather than something to retrieve.

Here’s the output that prompt should produce — statically reviewed against the 4.7 API:

GDScript

extends CharacterBody2D

@export var speed: float = 220.0

@onready var sprite: AnimatedSprite2D = $AnimatedSprite2D

func _physics_process(_delta: float) -> void:
	var direction := Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
	velocity = direction * speed
	move_and_slide()

	if direction != Vector2.ZERO:
		sprite.play("walk")
		sprite.flip_h = direction.x < 0.0
	else:
		sprite.play("idle")

Note what the prompt bought you: typed variables, @export for the designer-facing value, the correct move_and_slide() signature, and no invented node paths. That last one matters — without the scene tree in the prompt, models reliably hallucinate $Sprite or $AnimationPlayer and you’ll spend longer debugging node paths than writing the script yourself.

Option 1: Chat models

Setup: none. Cost: free to ~$20/month. Best for: learning, one-off scripts, debugging errors.

The zero-friction path is a browser tab. Open Claude or ChatGPT, paste your error, get an explanation. For a solo developer learning Godot, this is genuinely the highest-value-per-minute use of AI in the entire stack — not code generation, but error translation.

Godot’s parser errors are terse. Invalid call. Nonexistent function 'get_next_path_position' in base 'Nil' tells an experienced developer that a node reference is null; it tells a beginner nothing. Paste it with the script and you get a diagnosis in seconds.

Where chat models earn their keep

• Explaining an unfamiliar error or engine concept
• Writing shader math you’d otherwise spend an afternoon deriving
• Converting a system from one pattern to another (callbacks to signals, for instance)
• Generating boilerplate: save/load scaffolding, settings menus, object pools
• Reviewing a script you wrote and flagging what you missed

Where they fail, structurally

A chat model cannot see your project. It cannot run your game. It cannot read the error it just caused. Every piece of context arrives by copy-paste, which means the model’s understanding of your codebase is always a partial, stale snapshot you constructed by hand.

That ceiling is real and you hit it fast. The moment your question involves three scripts and an autoload, copy-pasting context costs more than writing the code. That’s the problem Option 2 exists to solve.

Option 2: MCP servers

Setup: 20–40 minutes. Cost: free to ~$20/month for the client. Best for: multi-file work, refactoring, debugging with real runtime state.

Model Context Protocol is a standard that lets an AI client call tools on your machine. A Godot MCP server exposes your project as those tools: read the scene tree, inspect a node, edit a script, launch the game, read the error output.

The practical difference is that the model stops guessing. It queries your actual scene hierarchy instead of inventing one. When the game crashes, it reads the real stack trace. It’s the single largest quality jump available in AI-assisted Godot work, and it’s the part almost no guide covers properly.

Install Node.js first

Nearly every Godot MCP server is a Node package launched through npx. If Node.js isn’t installed, npx doesn’t exist, the server can never start, and your client reports something unhelpful like Connection closed. This is the single most common reason a Godot MCP setup “doesn’t work”, and almost no guide mentions it.

Check before you touch any config:

node --version
npx --version

If either command is not recognised, install the Node.js LTS build and restart your terminal and your AI client before going further. On Windows, winget install OpenJS.NodeJS.LTS does it in one line.

Setup

Pick a server (comparison below) and add it to your MCP client config. For most Node-based servers this is a small JSON block:

JSON config

{
  "mcpServers": {
    "godot": {
      "command": "npx",
      "args": ["-y", "@coding-solo/godot-mcp"],
      "env": {
        "GODOT_PATH": "C:\\Godot\\Godot_v4.7.2-stable_win64.exe"
      }
    }
  }
}

Two details in that block do real work, and leaving either out is what breaks most first attempts:

• The -y flag. Without it, npx stops on first run to ask whether you want to install the package. Nothing is there to answer, so the server hangs and the client eventually gives up.
• GODOT_PATH. Servers try to auto-detect Godot by scanning standard install locations. Godot ships as a portable executable that most people unzip wherever, so auto-detection usually fails and the server falls back to a default path that does not exist. Point it at the real binary. Somewhere stable, not your Downloads folder — if the path changes, the server breaks again.

Install the companion addon into your project, if the server ships one, and enable it in Godot under Project → Project Settings → Plugins.

Restart your AI client and confirm the Godot tools registered. You should see a list of tool names appear in the client’s MCP panel — scene-tree reads, node inspection, script editing, project launching. For reference, @coding-solo/godot-mcp registers 14: launch_editor, run_project, get_debug_output, stop_project, get_godot_version, list_projects, get_project_info, create_scene, add_node, load_sprite, export_mesh_library, save_scene, get_uid and update_project_uids.

If that list is empty, the client never loaded your config — check the file path and restart again before touching anything else.

Verify with a read-only prompt before letting it write: “Show me the current scene hierarchy.” If that returns your real nodes, the connection is live.

Which server

The category is young and moves fast. Check the last-commit date on any of these before committing to it — an abandoned MCP server breaks the moment Godot changes a class reference.

The runtime-state approach deserves a specific mention: instead of asking the model to read a screenshot and guess where things are, it hands over exact positions and node state as structured data. For debugging a physics bug or a broken state transition, that’s the difference between a useful answer and confident fiction.

The honest caveat

MCP gives the model write access to your project. Use version control. Commit before a session, review the diff after. This is not a hypothetical concern — an agent confidently refactoring six scripts at once will occasionally delete something you needed.

Option 3: AI inside the editor

Setup: 10 minutes. Best for: developers who want AI in the same window as the scene view.

Editor plugins add a chat panel to stock Godot. The workflow advantage is small but real: your current script and scene tree are injected automatically, so the context problem from Option 1 mostly disappears without the setup cost of Option 2.

Install path is standard — AssetLib tab, or drop the folder into addons/ and enable it under Project → Project Settings → Plugins.

Two things to check before you install any of them:

Where does the API key live? Well-built plugins store keys in Godot’s EditorSettings, which stays out of your project files and out of git. If a plugin asks you to paste a key into a project resource, don’t — you will commit it eventually.

Can it run locally? Several plugins support Ollama pointed at http://127.0.0.1:11434. Pull a code-focused model and you get a fully offline assistant with no per-token cost and no code leaving your machine. Slower and less capable than a frontier model, but for boilerplate and syntax questions it’s more than adequate — and for anyone under NDA or working on contract code, it’s the only viable option.

Option 4: AI inside your shipped game

This is a completely different engineering problem from everything above. Options 1–3 help you build. This ships to the player.

Two architectures, and the choice determines your costs, your privacy exposure, and whether your game works offline.

Route A: Local models (recommended for most indie games)

NobodyWho is a GDExtension plugin that runs GGUF-format language models directly inside your game. No API key, no network, no per-player cost. It’s built on llama.cpp with Vulkan and Metal GPU acceleration, ships drop-in nodes, and supports streaming, tool calling, and grammar-constrained output.

The architecture is straightforward: a model node loads the GGUF file once, and chat nodes attached to individual NPCs share it. Responses arrive as signals, token by token, so inference never blocks your frame loop.

Three gotchas that sink projects:

1. Export size. A 3B-parameter quantised model is roughly 2 GB. On mobile, keep it under ~1 GB or the device runs out of memory. Your 40 MB indie game becomes a 2 GB download — decide whether that’s acceptable before you build a story around it.
2. Share the model node. Loading the same model once per NPC will consume gigabytes of RAM and freeze the game. One model node, many chat nodes.
3. Licensing. NobodyWho is EUPL-1.2 — free for commercial games, with the obligation that modifications to the plugin itself get published. Check the terms yourself before you build a commercial release on it, and check the licence of the model separately. They are not the same licence.

Route B: Cloud APIs — and the security rule you cannot break

Never ship an API key inside an exported Godot game. Not in a .tres, not in an autoload constant, not obfuscated. Exported PCK files are trivially unpackable. A key in your build is a key in a stranger’s terminal, billed to you.

The correct architecture:

Godot client  →  your backend (holds the key, rate-limits per user)  →  AI provider

Your game sends the player’s input to a server you control. That server attaches the key, enforces per-user rate limits, and returns the response. Yes, it’s more work. It’s also the only version that survives contact with the public.

Here’s a working HTTPRequest pattern — pointed at a local Ollama instance so you can run it today with no key and no backend, then swap the URL for your proxy when you ship:

GDScript

extends Node

# Use 127.0.0.1, not "localhost" — see the note below this block.
const ENDPOINT := "http://127.0.0.1:11434/api/generate"

@onready var http: HTTPRequest = $HTTPRequest

signal reply_received(text: String)

func _ready() -> void:
	http.request_completed.connect(_on_request_completed)
	http.timeout = 30.0

func ask(prompt: String) -> void:
	var headers := PackedStringArray(["Content-Type: application/json"])
	var payload := {
		"model": "llama3.2",
		"prompt": prompt,
		"stream": false
	}
	var error := http.request(
		ENDPOINT,
		headers,
		HTTPClient.METHOD_POST,
		JSON.stringify(payload)
	)
	if error != OK:
		push_error("Request failed to start: %d" % error)

func _on_request_completed(
	result: int,
	response_code: int,
	_headers: PackedStringArray,
	body: PackedByteArray
) -> void:
	if result != HTTPRequest.RESULT_SUCCESS:
		push_error("Transport failure: %d" % result)
		return
	if response_code != 200:
		push_error("HTTP %d" % response_code)
		return

	var parsed: Variant = JSON.parse_string(body.get_string_from_utf8())
	if parsed == null or not parsed is Dictionary:
		push_error("Malformed JSON response")
		return

	reply_received.emit(parsed.get("response", ""))

Use 127.0.0.1, not localhost — this one costs people hours

Almost every Ollama snippet on the internet uses http://localhost:11434. On Windows that fails, and it fails in the most confusing way possible.

Windows resolves localhost to the IPv6 address ::1 first. Ollama binds IPv4 only — run netstat -ano | findstr 11434 and you’ll see it listening on 127.0.0.1:11434 and nothing else. So Godot dials an address nothing is listening on, waits out the full 30-second timeout, and hands you Transport failure: 13 with no further clue. Result code 13 is RESULT_TIMEOUT.

The maddening part is that testing the same URL in PowerShell or a browser works fine, because those clients fall back to IPv4 automatically. Godot’s HTTPRequest does not. Hardcode 127.0.0.1 and it works immediately.

Here’s that script running against a local Ollama instance, printing the model’s reply straight into the Godot Output panel:

Three details worth noticing, because generated versions of this script usually get them wrong: body is a PackedByteArray and needs get_string_from_utf8() before parsing; JSON.parse_string() returns null on failure rather than throwing, so the null check is mandatory; and result and response_code are different failure modes — a connection that never opened and a server that returned 500 need different handling.

Structure: put this on a dedicated node with an HTTPRequest child, expose the result as a signal, and let NPC scripts connect to it. Do not call it from _process.

Costs and latency, honestly

Cloud inference costs money per player, per conversation, forever. A chatty NPC in a game with 10,000 players is a recurring bill with no ceiling.

Latency has to be designed around either way. Four consecutive runs of the script above, against a warm local model on a laptop CPU, returned in 773 ms, 1909 ms, 3116 ms and 5409 ms. That is a 0.5B model — about as small and fast as a usable model gets. Anything you would actually ship for dialogue is slower, and a cloud round trip adds network time on top. Budget for one to five seconds, and spend it: a typing animation, a thinking pose, something that makes the wait diegetic.

Local inference removes the bill but costs you download size and requires a fallback path for weak hardware.

Most shipped games that use LLMs for dialogue use them for flavour — barks, reactions, ambient chatter — and keep critical plot dialogue hand-written. There’s a reason for that. Generated text can’t be guaranteed to stay on-brand, on-rating, or on-plot.

Classic game AI: what most people actually need

If you searched “AI in Godot” wanting enemies that chase the player, none of the above applies. You need a state machine and a navigation agent. This is deterministic, debuggable, free, and it’s what almost every shipped game uses.

An enemy scene needs: a CharacterBody2D root, an AnimatedSprite2D, a CollisionShape2D, an Area2D with a larger shape for detection, and a NavigationAgent2D.

GDScript

extends CharacterBody2D

enum State { IDLE, CHASE, ATTACK }

@export var move_speed: float = 120.0
@export var attack_range: float = 40.0

@onready var nav: NavigationAgent2D = $NavigationAgent2D

var state: State = State.IDLE
var player: Node2D = null

func _physics_process(_delta: float) -> void:
	match state:
		State.IDLE:
			velocity = Vector2.ZERO
		State.CHASE:
			_chase()
		State.ATTACK:
			velocity = Vector2.ZERO
			_attack()
	move_and_slide()

func _chase() -> void:
	if player == null:
		state = State.IDLE
		return
	if global_position.distance_to(player.global_position) <= attack_range:
		state = State.ATTACK
		return
	nav.target_position = player.global_position
	var next_point := nav.get_next_path_position()
	velocity = global_position.direction_to(next_point) * move_speed

func _attack() -> void:
	if player == null or global_position.distance_to(player.global_position) > attack_range:
		state = State.CHASE

func _on_detection_area_body_entered(body: Node2D) -> void:
	if body.is_in_group("player"):
		player = body
		state = State.CHASE

Connect the Area2D’s body_entered signal to _on_detection_area_body_entered, add the player to a player group, and bake a navigation mesh in your level. That’s a functioning enemy.

Here it is running — that exact script, unmodified, in a Godot 4.7.2 project:

The HUD in that shot reads the state straight off the enum every frame, which is worth doing while you build one of these. A state machine that transitions wrongly looks identical to one that transitions correctly until you print the state.

Three things that will bite you

An unbaked navigation mesh. NavigationAgent2D returning Vector2.ZERO from get_next_path_position() almost always means the navigation mesh hasn’t been baked or the agent is outside it. It’s the most common failure here by a wide margin.

The enemy never goes back to IDLE. There’s no body_exited handler in the script above, so once the player is seen the enemy chases forever, across the whole level, through every room. That’s often what you want in a small game and it keeps the example short — but if you want the enemy to give up, connect body_exited too and set the state back to IDLE with player = null.

Collision layers. If the enemy and player physically block each other, they will jam against one another and the chase stops dead. Put them on separate collision layers, and mask the detection Area2D to the player’s layer only — otherwise the area detects walls, or the enemy detects itself.

When this outgrows you — more than five or six states, or behaviours that need to share sub-trees — graduate to a behaviour tree via LimboAI or Beehave. Don’t start there. A three-state match statement is easier to debug than a tree, and most enemies never need more.

AI coding assistants are genuinely good at generating this scaffolding, which is the neat convergence: use Option 1 or 2 to write your classic game AI, and skip the language model at runtime entirely.

Download the demo project

Both screenshots above come from one small Godot 4.7.2 project, and you can have it. The enemy script in it is character-for-character the one printed on this page — the screenshot is evidence the published code runs, not a lookalike built separately.

>>> DownZIP FILE HERE <<<

Open the folder in Godot 4.7.x and press F5 for the enemy state machine. The player walks a patrol loop on autopilot so you can watch the states change without touching the keyboard — press Space to take control. Run ollama_demo.tscn for the HTTPRequest demo; it needs Ollama running locally with a model pulled.

A realistic workflow

The pattern: AI is strong where output is checkable and weak where quality is felt rather than measured.

What AI still gets wrong in Godot 4.7

Beyond the version problem, these recur:

• Signal connections written in the Godot 3 string style, or connected twice, producing double-fire bugs that look like physics problems.
• @onready ordering. Models assume a node exists before _ready() runs. It doesn’t.
• _process vs _physics_process. Movement put in _process will be frame-rate dependent, and the bug only appears on other people’s machines.
• Invented node paths. $Sprite instead of $Sprite2D, $Player/Anim for a node that was never in your tree.
• Autoload assumptions. The model assumes a GameManager singleton exists because most tutorials have one.
• Return-type drift. Godot 4 tightened typing; generated code often omits -> void or returns a Variant where a typed value is required.
• Hostnames. As above — every local-inference snippet says localhost, and on Windows that breaks silently.

What this guide was tested on

Versions matter more than usual in this topic, so here is exactly what produced the screenshots and the timings, rather than numbers copied out of documentation:

More guides

• Claude Code Unity MCP Setup: 3 Routes Compared

Related guides

• Claude for Game Development: Build Smarter in Unity, Godot & Unreal
• Best AI Code Assistants for Unity C# Beginners: Write Scripts Faster
• How to Vibe Code a Game: The Step-by-Step Guide (2026)

Frequently asked questions

Where to start

Pick one:

• Learning Godot? Option 1, plus the translation table. Cost: nothing.
• Building something real? Option 2. The setup pays for itself the first time you refactor across files — and check Node.js is installed before you blame the server.
• Want talking NPCs? Option 4, Route A, local. Prototype before you design a game around it.
• Want an enemy that chases the player? The state machine above. No language model required.

And whatever you generate — commit before, review after, read every line. The tools are genuinely good now. They are not, and are not close to, trustworthy without supervision.