Citation and evidence

Developing Games with AI

55 min full readUpdated 121 references

This article's verification

Report a problem with this article

Edit article
More

Cite this article

Developing games with AI means using generative AI during game design and production, or incorporating a model into the game itself. These are different engineering tasks. A coding assistant can help change a project without becoming part of the released game; an image generator can supply an asset that ships with it; a dialogue model used during play creates an ongoing runtime dependency. Research on AI for games distinguishes design assistance from roles inside the game, such as NPC behavior.[32]

This guide follows a practical route from a small playable prototype to a tested build: choosing a stack, connecting a coding agent to the engine, writing project instructions, letting the agent run and inspect the game, producing assets, controlling cost and preparing a release. The workflow and templates are recommendations, not a benchmark or a promised schedule. Tool versions and commands come from each project's own documentation as of 30 October 2026 and change often; check the linked source before running anything. A developer still decides what the game should do, inspects the changes and judges how it plays.

This is a step-by-step guide. For background, research, industry surveys, case studies and store rules, see AI game development.

Follow the guide series

Use this page for the shared workflow and choose one engine guide for implementation. Read the asset and testing guides when the prototype reaches those stages; a first project does not require learning four engines.

GuideUse it whenWhat you will work toward
Developing Browser Games with AIYou want a small JavaScript or TypeScript game that players open in a browserA versioned web project with working input, resizing and a tested hosted build
Developing Godot Games with AIYou want Godot's scene and node workflowA small project with connected scenes, explicit input actions and an export you can run
Developing Unity Games with AIYou are using a Unity project and C#A reviewed gameplay change with editor, test and build evidence appropriate to the installed tools
Developing Unreal Engine Games with AIYou need an Unreal project using Blueprints, C++, or bothA bounded feature checked in the editor and packaged game
Developing Roblox Games with AIYou are building a Roblox experience in Roblox Studio with LuauAn agent connected through Studio's MCP server and one server-validated mechanic tested with several clients
Creating Game Assets with AIYour placeholder game works and needs an art or audio pipelineImported assets with technical acceptance checks and records of their origin and permitted uses
Adding Generative AI Features to GamesThe game itself will call a model while people playA design in which the model proposes, game code validates and every failure has a fallback
Testing and Releasing AI-Assisted GamesYou are preparing a build for other playersA release candidate with repeatable checks, playtest evidence and applicable disclosures

Expanded article table

A practical order: define one game loop here, follow the chosen engine guide, accept a small asset set, then test and release. With no game yet, start with Your first game, step by step; with a working game already, enter at the relevant stage. The outcomes are learning goals, not results a prompt guarantees.

Four steps: specify the outcome, change one mechanic, inspect evidence, and keep a recoverable checkpoint.

A small change is easier to judge when its expected behavior, evidence and recovery point are explicit. This diagram summarizes the guide's recommended workflow.

Quick start

For a first project, choose one complete interaction, not an entire commercial game. A one-room game in which the player collects objects while avoiding an enemy exercises movement, collision, scoring, failure and restarting. Godot's official first-game tutorial similarly teaches a complete small 2D project, while Phaser's introductory tutorial builds a small platform-and-collection game.[2][3]

Use placeholder shapes until the rules work, so a change in visual style does not become entangled with a broken movement or collision system.

Your first game, step by step

This walkthrough builds a one-room collect-and-avoid game from Phaser's official template with a coding agent. It needs no engine bridge: the agent edits files and runs commands, and the game runs in a browser. The Phaser, npm, Playwright and Vite commands match Developing Browser Games with AI as of 30 October 2026; the prompts are examples. Finish each check before the next step.

  1. Install the tools. Install Node.js, which the template's README says "is required to install dependencies and run scripts via npm" (Playwright, used in step 8, lists the latest 22.x, 24.x or 26.x),[72][81] Git, and a coding agent that runs shell commands, such as Claude Code (started with claude, which asks you to log in on first use) or Codex (started with codex, which offers Sign in with ChatGPT).[75][76] On a computer where Git has never been used, set a name and email once with git config --global user.name "Your Name" and git config --global user.email you@example.com, replacing the placeholders.[78] Check: each tool starts from a terminal; claude --version prints a version number.[75]

  2. Create the project.[57][73]

    npm create @phaserjs/game@latest my-game
    

    Phaser recommends that first-time users choose Web Bundler and then Vite; this walkthrough then picks Minimal (Single Phaser Scene) and JavaScript. The tool also asks permission to anonymously record which template was selected, and quits if you answer no.[73][74] Check: the tool reports success and lists the next steps cd my-game, npm install and npm run dev.[74]

  3. Run it unmodified.

    cd my-game
    npm install
    npm run dev-nolog
    

    The plain dev and build scripts run a log.js file that sends the template name, build type and Phaser version to a Phaser Studio domain; the -nolog variants skip it.[72] Check: open the address the server prints (http://localhost:8080 by default) in a browser; the template game appears with no console errors. Leave the server running.

  4. Commit the baseline. In a second terminal, inside my-game:

    git init
    git add .
    git commit -m "Unmodified Phaser template"
    

    git add given a directory adds all of its files, and the template's .gitignore already excludes node_modules and dist.[79][80][72] Check: git status reports "nothing to commit, working tree clean".[80]

  5. Write a short project instructions file. Name it CLAUDE.md for Claude Code or AGENTS.md for Codex, which reads AGENTS.md files "before doing any work" (Write a project instructions file explains how the names interact).[27][77] Phaser's pages tell AI agents to start users with its commercial Phaser AE rather than the open-source framework, so say which one the project uses.[73] An example:

    Game: one-room collect-and-avoid game in the open-source Phaser
    framework already installed. Do not switch to Phaser AE or add
    packages without asking.
    Dev server: npm run dev-nolog (http://localhost:8080)
    Build: npm run build-nolog (output: dist/)
    Done means: the build succeeds, and the report lists files changed,
    commands run with their output, and what still needs manual testing.
    

    Check: the file is committed.

  6. Prompt 1: one mechanic. Start the agent inside my-game. An example prompt:

    Read the project instructions and src/game. Replace the template
    scene's content with one room: a player square that moves with the
    arrow keys and cannot leave the room, and five tokens. Touching a
    token removes it and adds exactly 1 to an on-screen score. No enemy
    yet. Run the build, then list the files you changed.
    

    Check: push against every wall and collect all five tokens; the score ends at 5. Ask the agent to explain any change you do not follow, then commit; if an attempt makes things worse, return to the last commit.

  7. Prompt 2: failure and restart. An example prompt:

    Add one hazard that moves back and forth. Touching it ends the round
    with "You lose"; collecting the fifth token ends it with "You win".
    Both end screens offer a restart that resets the score, the tokens
    and the hazard. If the last token and the hazard are touched in the
    same update, the win takes priority.
    

    Check: win once, lose once and restart after each; later rounds start with a score of 0, five tokens and one hazard. Commit.

  8. Add a first automated check. Install Playwright Test, accepting its default answers:[81]

    npm init playwright@latest
    

    An example prompt:

    In development builds, expose a read-only window.__GAME__ object with
    the score and round state. Configure Playwright's webServer to run
    npm run dev-nolog at http://localhost:8080, with reuseExistingServer:
    !process.env.CI so it reuses the server already running. Add a test that collects
    one token and expects a score of 1. Run npx playwright test and show
    me the output.
    

    Playwright's webServer option starts the development server before the tests;[82] the browser guide's first Playwright test shows the pattern in full. Check: npx playwright test passes;[81] then have the agent change the expected score to 2 and confirm the test fails.

  9. Build the production version.

    npm run build-nolog
    npx vite preview --config vite/config.prod.mjs
    

    The build goes to dist; the template has no preview script, so the second command runs Vite's local preview server (not for production use) with the template's production configuration.[72][83] The template's production configuration sets logLevel: 'warn', which hides the address Vite would otherwise print; the preview server listens on port 4173 by default, or the next free port.[72][119] Check: open http://localhost:4173, then play a round and restart.

  10. Publish a test build. On itch.io, create a project of the kind "HTML Game" and upload a ZIP of everything inside dist; it must contain index.html, filenames are case sensitive and paths should be relative, as the template's base: './' setting makes them.[84][72] A new project starts in Draft, open only to its editors and people with the secret link.[85] For GitHub Pages or Cloudflare Pages, see the browser guide's hosting table. Check: the uploaded page plays in a fresh browser window, and on a phone if phones are supported.

  11. Ask someone else to play. Give someone who has not seen the project the link and no verbal instructions, note where they hesitate, and record which commit the build came from. Check: they can start, win or lose, and restart without help. Then continue with Work through one complete prototype or an engine guide.

Pick a starting path

The table pairs common kinds of project with how an agent reaches them and the guide with the setup. "Bridge" means an MCP server, plugin or command-line tool that lets an agent act inside the engine rather than only editing files. Version requirements and commands are in each guide.

Kind of gameEngine or toolHow the agent reaches itGuide
A quick idea, without codePrompt-to-game servicesThe service generates and hosts the gameWithout code
Small 2D or 3D browser gamePhaser or three.jsNo bridge: the agent edits files and the game runs in a browser[53]Browser; walkthrough
Scene-based 2D or 3D gameGodotThe engine's command line, or Godot MCP by Coding-Solo[56][34]Godot
Unity projectUnityUnity CLI, Pipeline package and plugin; community bridges such as Funplay MCP for Unity[35][37][40]Unity
Unreal projectUnreal EngineEpic's Unreal MCP plugin (Experimental); community unreal-mcp[43][44]Unreal Engine
Roblox experienceRoblox StudioStudio's Assistant, or an external agent through Studio's MCP server[116][117]Roblox
3D assets for any engineBlenderCommunity MCP for Blender or Blender Lab's MCP Server[45][46]Assets; Blender MCP

Expanded article table

Browser games (Phaser or three.js)

Full guide: Developing Browser Games with AI.

A small browser project needs no engine-editor integration: Simon Willison wrote in October 2026 that all of his games so far had been "HTML and JavaScript using static hosting".[53] Because the game is a static page, an agent with a browser or screenshot tool can open it and check the result directly; see Let the agent see and play the game.

Without code: prompt-to-game tools

Some services turn a plain-language description into a playable game that they also host, with nothing to install. The games-industry newsletter Naavik reported in October 2026 that every prompt-to-game platform it tested produced a playable game in under 20 minutes, but that the results tend to be bite-sized, close to hypercasual games; it quoted Meta's Horizon lead, Saxs Persson, as saying that AI generation starts to drift after the first ten or so prompts.[86] As of 30 October 2026:

  • Playground (Google Labs): an experimental, chat-based browser game creator for users aged 18 and over. Google's help center said it was available in the United States, with free-tier users joining a waitlist and Google One AI plan subscribers getting immediate access.[87][88] Creators can export a ZIP of the game's HTML, JavaScript, CSS and generated assets,[88] and Google's terms say it does not claim ownership of creators' games.[89]
  • Unity Spark: Unity's prompt-driven game maker, whose product page still read "Coming Soon", with a closed-beta waitlist.[90] GamesIndustry.biz reported that at launch it will not be possible to download Spark projects, export them to the desktop Unity engine or sell them.[91]
  • Rosebud AI (a Y Combinator Summer 2019 company):[92] it says it generates JavaScript game code, art and sound and publishes games as links.[93] Code download starts at its Pro plan and full commercial rights at its 10x Dev plan.[94] Its terms state that Rosebud owns material "created or generated as a result of any Prompt" and let it share anonymized user data with third parties, including for AI model training, with no opt-out.[95]
  • Astrocade: short games that its chief executive calls "playables", distributed through Astrocade's own feed; GamesBeat reported that creators are paid according to how much their games are played.[96] Its MCP server lets coding agents such as Claude Code, Codex and Cursor build and publish Astrocade games.[97]
  • Inside existing platforms: Roblox Build, a tab in the Roblox app announced in July 2026, turns a prompt into a basic game; its public alpha began in New Zealand and in September 2026 expanded to Serbia and Singapore.[98][118][86] Roblox described its September Build announcements as "the first steps toward integrating Build and Studio".[118] Meta's Horizon Create and Horizon Studio, announced in September 2026 with an early-access waitlist, make games that, once published, are eligible for distribution on Facebook, Instagram and Horizon.[99][86]

These tools trade control for speed, and export, ownership and commercial rights vary by service and plan, so read the terms before investing in a game you may want to sell. Move to an engine guide when prompts stop producing the change you want, when you need version control or tests, or when you want to release the game elsewhere. A Playground export is ordinary HTML and JavaScript and can continue as a browser project. For a no-code engine with its own AI agent, see GDevelop under Other engines.

Separate development tools from runtime AI

UseWhat is producedPractical consequence
Development assistanceSuggested code, explanations, editor operations or test scriptsReview the resulting project; the assistant need not run for players
Pre-generated contentImages, meshes, audio, dialogue or other material prepared before releaseReview the retained files, their suitability and their permitted uses
Runtime generationContent produced while someone playsPlan service access, cost, response time, validation and failure behavior
Conventional game AIAuthored decision rules, navigation or other game systemsThis does not automatically require a generative model

Expanded article table

Unreal Engine's Behavior Trees, for example, choose behavior from authored logic and Blackboard values, so an "AI enemy" need not use an LLM.[4] Steam's disclosure guidance likewise separates content prepared before release from live-generated content.[5]

Choose an engine and an assistant

Choose the engine around the platform, the game's requirements and the skills available to maintain it, not around an assistant. Phaser is a web-focused 2D framework for JavaScript or TypeScript;[6] Godot organizes games as scenes composed of nodes;[7] Unity documents an in-editor assistant, generators and support for external agents;[8] Unreal's Blueprints provide node-based gameplay scripting that can extend systems written in C++.[9] Tell the assistant the installed version and the structures it must respect, such as the scene tree or whether a task concerns C++, Blueprint graphs or both.

A chat interface is useful for explanations and for reviewing material pasted into it. A coding agent such as Claude Code, OpenAI Codex or Cursor can edit files and run commands when its harness provides those tools. Instructions supplied to an agent are not the same as tools that control an editor: Unity's official plugin, for example, supplies skills, and its editor-control skills depend on the separately installed Unity CLI.[10][37] Test a candidate assistant on a small task from the actual project, checking whether it can inspect the required files, use documentation for the installed version, run the relevant checks and show what changed.

Compare models on game-development tasks

GameFeel Benchmark evaluates mechanic implementation and debugging separately from human ratings of balance changes, ideas, visuals and audio. Its reverse-evaluation tasks ask models to judge other models' work and game changelogs. These are the maintainer's disclosed tests, so use the relevant category to identify a candidate for a project trial rather than treating the overall score as a forecast for every game.[120]

For that trial, this guide recommends giving each candidate the same small mechanic, reproducible bug and balance proposal. Keep the starting commit, tool access and budget fixed. Build and test the code, then play the changed game and assess balance separately. Record the model and effort setting, task cost and time spent checking and repairing its work.

Keep the uncertainty in early Qwen labels: the dashboard flags qoDuck and qoHawk with warnings, and their tentative identifications do not confirm official model releases.[121] Its task prices also distinguish subscription, API and free access.[120][121] A benchmark-task cost does not establish the cost of another project's workload, so compare measured cost and accepted results in the actual project.

Set up a project that can be recovered

Create a working baseline before the first generated change. Record the engine version, important packages, target platform and how to run the project. Save a version-control checkpoint, then make changes in a branch or another isolated working copy.

Use the engine's own version-control guidance rather than a generic ignore file. Godot documents different exclusions for older versions and for Godot 4.1 onward, and its project manager can generate Git metadata.[11] The Unity CLI's guided unity vcs setup creates a repository and pushes the first commit.[35] Keep the source assets and configuration needed to reproduce the project; exclude generated caches and credentials.

For an agent with command or editor access, limit permissions to the project and the tasks it needs. Review new dependencies, scripts and editor extensions before executing them. Keep service keys and signing credentials outside prompts and source control. GitHub's documentation warns that generated suggestions can be inaccurate or insecure and calls for review and testing.[12]

Write down project-specific constraints, such as the permitted asset directories, the rendering pipeline and the command that actually builds this project. A written preference still needs a technical control if violating it would matter. Claude Code's permission settings are one such control: deny and ask rules in a settings file block or require confirmation for matching tools, and a single rule such as Bash(git push *) refuses commands that begin with git push, though not a push written another way, such as git -C . push.[49] An illustrative project .claude/settings.json for a game repository, built from the documented rule syntax, might be:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git commit *)"
    ],
    "ask": [
      "mcp__blender__execute_blender_code"
    ],
    "deny": [
      "Bash(git push *)",
      "Read(./.env)",
      "Edit(/ProjectSettings/**)"
    ]
  }
}

The rule names use Claude Code's documented forms (Bash(...), Read(...), Edit(...) and mcp__<server>__<tool>).[49] Here execute_blender_code is the code-execution tool of the community MCP for Blender.[45] Replace ProjectSettings with the folder to protect. The documentation notes that a Bash rule does not match every way of writing a command, so treat such rules as a guard rail, not a sandbox.[49]

Write a project instructions file

Coding agents read a Markdown file of project instructions, but file names and loading rules differ by tool. Claude Code reads CLAUDE.md (or .claude/CLAUDE.md). Reading AGENTS.md directly requires Claude Code v2.1.277 or later, and by default Claude reads it only when no CLAUDE.md, .claude/CLAUDE.md or CLAUDE.local.md exists in the working directory or a directory above it. The Project instructions setting changes that default, and a CLAUDE.md can also import the shared file with an @AGENTS.md line.[27] The AGENTS.md maintainers describe "a simple, open format for guiding coding agents" and list supporting tools that include Codex, Cursor, Gemini CLI and GitHub Copilot's coding agent; check each tool's own discovery rules rather than assuming they match Claude Code's.[48]

Anthropic suggests a target of "under 200 lines per CLAUDE.md file" and instructions "concrete enough to verify", holding only what Claude "couldn't work out from the code itself"; it calls the command that runs the project's checks "the single most useful line" in such a file.[27][13] /init generates a starting file from the codebase.[27] Claude treats the file "as context, not enforced configuration", so hard limits belong in permission rules or hooks.[27][13]

The following is an illustrative template for a small Unity game, not an official format (in a real file the section labels would usually be Markdown headings). Every command in it must be replaced with the ones that actually work in the project:

Game: [working title]

Engine and versions:
- Unity [exact Editor version], render pipeline: [URP/HDRP/Built-in]
- Key packages: Input System [version], TextMeshPro [version]
- Target: Windows desktop, 1920x1080 and 1280x720

How to build and test:
- Compile check: `unity recompile`
- Batch tests (only when no Editor has this project open): `unity test`
  - Exit code 8 means tests failed: fix them before another run.
- Tests in an already open Editor: use the installed Pipeline test
  command after checking that Play Mode is stopped.
- Headless build: `unity build` with the profile in Assets/Settings/Build
- After any gameplay change: enter Play Mode through the MCP bridge,
  take a game-view screenshot and read the console log before reporting.

Folder rules:
- Gameplay code: Assets/Scripts/Gameplay/
- Generated art goes to Assets/Art/_incoming/ until a human approves it.
- Do not edit: ProjectSettings/, Packages/manifest.json, Assets/Plugins/
  (ask first).

Acceptance checks for every task:
- The task's listed checks pass, with the command output in the report.
- No new compiler warnings.
- Existing tests still pass.
- Report files changed and anything that still needs manual play-testing.

Working notes:
- Backlog: docs/backlog.md (one task per card; update status when done).
- Design decisions: docs/design.md. Do not change rules without asking.

The three Unity commands are documented but run in different contexts. unity recompile needs a running Editor with the Pipeline package. unity test starts its own batch Editor, so it refuses a project already open in an Editor (exit code 6); for an open Editor, Unity's skill reference says to use the Pipeline's run_tests command, only after editor_status shows that Play Mode is stopped. Exit code 8 means "The tests ran, and one or more failed".[38][70] Keep the backlog and design notes in files the agent can read: the Ashen Crown developer said that structured task descriptions let "work continue across sessions without losing track of which version we are building".[29]

Connect the agent to the engine

An agent reaches a game by editing project files and running the engine's command-line tools, or through a bridge inside the open editor. Either way, the useful result is evidence (logs, screenshots, test output) that a person checks against the running game; a bridge does not replace independent build and play checks. Setup commands live in the engine guides.

Flow diagram: a coding agent reaches the engine or editor either by editing project files and running command-line tools or through an engine bridge; the engine produces a running game or build, whose logs, screenshots and test output go back to the agent and to a person who reviews them.

This guide's recommended way to work with an agent: whichever route it uses, judge a change by the evidence it produces and by playing the game, not by the agent's report. A bridge does not replace independent build and play checks.

What a bridge adds

Without a bridge, an agent edits files and has to guess what the editor will do with them. The Just Farm developer described Funplay MCP with Unity 6 as letting Claude "inspect scenes, change values, take screenshots and play the game, so it can see what it built instead of guessing".[28] The subsections below cover the main bridges; this list adds others. Test an installed connection rather than assuming every documented capability works.

  • MCP for Unity (CoplayDev, MIT) and Unity-MCP (Ivan Murzak): further community bridges; Unity-MCP can also run inside a compiled game.[41][42]
  • unreal-mcp (chongdashu, MIT, experimental): actors, Blueprint classes and node graphs, and viewport control, through a native TCP server in a C++ plugin.[44]
  • MCP for Blender (ahujasid, MIT): tools including execute_blender_code, look (multi-angle, wireframe or rendered views) and generate_3d, over a socket server with "no authentication or encryption".[45]
  • Blender Lab MCP Server (Blender Foundation): access to Blender's Python API and documentation; it runs LLM-generated code "without any guards" and recommends a virtual machine.[46]

Godot: Godot MCP

Coding-Solo's community Godot MCP (MIT) launches the editor, runs and stops projects in debug mode, captures debug output and creates scenes and nodes, but has no screenshot or input tool.[34] The Godot guide's Coding-Solo Godot MCP section has the Claude Code command, the GODOT_PATH fallback and the entry for other clients. Start with a read-only request for the Godot version and project information, then ask the agent to run the project and summarize the debug output.

Unity: the official CLI and plugin

Unity's official route combines the Unity CLI, the Unity Pipeline package inside the Editor[39] and Unity's plugin, which supplies skills for Claude Code, Codex and Grok; Unity labels the CLI experimental.[35][37][69] unity command and unity eval drive the Editor, unity build, unity test and unity recompile build, test and compile, and unity mcp starts an MCP server; the pipeline server "accepts connections on localhost only".[36][38] Unity says the direct commands are "faster and use fewer tokens than MCP" and that the CLI "is free and separate from Unity AI".[36] With the plugin installed, "the agent asks questions before making changes rather than assuming", which can block automated pipelines unless prompts carry enough detail.[10][37] The install steps and requirements are in the Unity guide's official route.

Unity: Funplay MCP for Unity

Funplay MCP for Unity (MIT) is a community package whose per-project server offers play mode, simulated input, game-view capture, logs, tests and C# execution; "All exposed MCP tools run directly. There is no extra approval toggle".[40] The Just Farm developer, who wrote of having tested several MCP servers, called Funplay "the best one IMO".[28] The Unity guide's community routes give its install and client setup, and CoplayDev's.[41]

Unreal Engine: Epic's Unreal MCP

Epic's Unreal MCP plugin embeds an MCP server in the Unreal Editor for actors, lighting, material instances, automation tests and custom Python or C++ tools. Epic labels it Experimental, warns that "many features are incomplete or missing" and that the server has "no authentication layer", and says that tool invocations run "on the game thread serially, meaning clients should not issue overlapping Tool calls".[43] The community unreal-mcp route combines a C++ plugin with a Python server and says "Production use is not recommended at this time".[44] The Unreal guide's Unreal MCP section has the plugin settings, console commands, client configuration and troubleshooting.

Blender: MCP for Blender

Full guide to the asset stages: Creating Game Assets with AI.

The Blender MCP article explains the community MCP for Blender and Blender Lab's official server. The community server needs Blender 3.0 or newer, Python 3.10 or newer and uv; these documented forms add it to Claude Code (the first also turns on its optional safe mode) and install the add-on:[45][47]

claude mcp add blender --env BLENDER_MCP_SAFE_MODE=1 -- uvx mcp-for-blender
uvx mcp-for-blender install-addon

Then enable Interface: MCP for Blender under Edit > Preferences > Add-ons. If the server is not running, press N in the 3D viewport, open the MCP for Blender tab and click Start MCP Server. A client launched from a GUI may fail with spawn uvx ENOENT; put the full path to uvx in its configuration.[45] Blender Lab's server installs differently; follow its own page.[46]

Check the connection

After adding a server to Claude Code, claude mcp list shows a status for each one, such as "Connected" or "Failed to connect", and /mcp shows the same inside a session. A server committed in a project's .mcp.json stays at "Pending approval" until it is approved in an interactive session.[47] Ask a read-only question (the open scene, the selected actors, the Godot version) before letting the agent change anything.

Security checks before connecting a bridge

An engine bridge is code execution with the editor's privileges. Before installing one:

  • Read what it exposes (see the bridge summaries above). Blender Lab warns that its server runs generated code "without any guards in place to protect your data from removal or being sent to a remote location".[46]
  • Keep it local. Keep unauthenticated editor services on localhost. The community Blender project advises an SSH tunnel rather than pointing the server at a remote machine directly.[45]
  • Use the documented checks. Funplay keeps its code-safety checks on by default and can narrow its tool exposure.[40] Blender's BLENDER_MCP_SAFE_MODE=1 checks every script and blocks reading or writing files directly, running other programs, network access and code that keeps running after the script ends, while ordinary modeling, rendering, saving and import/export still work.[45] Treat these as code checks, not a verified sandbox.
  • Add agent-side limits. Use ask or deny permission rules for the riskiest tools, and run model-driven Blender sessions in a virtual machine or on a system without access to sensitive information, as Blender Lab recommends.[49][46]
  • Treat fetched content as untrusted. Claude Code's documentation warns that servers which fetch external content can expose the user to prompt injection.[47]

These risks are not hypothetical: in 2026 CVE records were published against the community Blender project, including CVE-2026-10688 against execute_blender_code and a path-traversal flaw fixed in blender-mcp 1.6.5 (CVE-2026-66004); the Blender MCP article lists them.[67][68] Keep bridges updated and review their release notes.

Other engines

Several other engines document their own routes for coding agents; the advice on project instruction files and security checks applies to them too. As of 30 October 2026:

  • GameMaker is a 2D engine scripted in its own GameMaker Language (GML).[100][101] Its GM-CLI toolchain, launched in April 2026, compiles, runs and packages projects without the IDE; Opera, which owns GameMaker, said that Claude Code can work through the CLI, and the CLI's README says gm-cli init can set up "AI agent integration (AGENTS.md, MCP, Claude config)".[101][102] GameMaker head Russell Kay told Game Developer that the tools are "complementary and opt-in".[103]
  • Bevy is a free, open-source Rust engine whose engine and game logic use an entity component system (ECS).[104][105] Its Bevy Remote Protocol, a JSON-RPC 2.0 protocol behind the bevy_remote crate feature, lets a separate process inspect and edit a running app.[106][107] The community MCP server bevy_brp_mcp uses it to let coding agents launch, inspect and modify Bevy apps; its README pairs each release with a Bevy version.[108]
  • Defold is a free, source-available 2D and 3D engine scripted in Lua.[109][110] Its manual says Defold works with Claude Code, Codex, Cursor or other agents through interfaces it already exposes, such as text-based project files, an editor HTTP API and engine automation APIs, that it "does not currently require an MCP server", and that community MCP projects are not supported by the Defold Foundation.[111]
  • GDevelop is an open-source, event-based engine that builds game logic without code; its site says it can package games for desktop, web and mobile.[112][113] Its built-in AI agent builds mechanics from plain-language requests, and the desktop app can let an external agent such as Claude Code, Cursor, Codex or Gemini CLI edit the open project over MCP.[114][115]

Work through one complete prototype

The following is an illustrative project specification. The numbers are design choices for this example, not research findings or recommended defaults for every game:

Build a single-player 2D game in one room. The player moves with the selected input controls, collects five objects and wins. Touching the enemy loses. A visible restart control starts a clean run. Use placeholder shapes. Exclude networking, accounts, purchases, procedural levels and generated dialogue.

Build it in separate increments (room and player; collectible and score; enemy and loss; win and restart; presentation; export and an external playtest), as Your first game, step by step does on the browser route. Complete and save each increment before adding the next. If one breaks the game, investigate that change before layering more generated systems over it.

Record a milestone before moving on

For the illustrative collect-and-avoid project, accept one checkpoint at a time:

MilestoneCheck in the running gameKeep with the checkpoint
Recoverable baselineUnmodified project opens and its first export launchesEngine and package versions, launch command, source commit and build path
Complete greybox loopMovement, five unique pickups, loss, win and restart follow the briefTested input sequence, observed result and remaining defects
Integrated presentationReplaced art and audio remain readable and correctly aligned in playApproved asset list, import settings and comparison captures
Candidate for feedbackAnother person can launch, understand and complete the distributed gameTested package, target device, feedback notes and issue list

Expanded article table

Define the result of simultaneous events, such as a final pickup and a hazard hit, before delegating implementation. When handing work to another agent or a later session, leave a short record: the last accepted commit, current task, files changed, checks run with results (separating passed from not run), known failures and the next bounded step.

A bounded feature prompt

This template expresses a task and its checks; it is not a special command:

Project: [engine and exact version], [target platform].
Task: Add one collectible that increments the existing score once.
Inspect the current implementation before proposing changes.
Keep the existing movement, art and input behavior.
Use the project's existing dependencies and conventions.
Acceptance checks: collection removes the object; score rises once;
restart restores the object and clears the score.
Implement the change, run the available checks, and report the files
changed, the checks performed and anything that still needs manual testing.

Describe visible behavior and constraints rather than asking for an unspecified "polish pass", and supply a screenshot or recording when layout, animation or timing matters. Anthropic's guidance on verification loops describes pairing an explicit expected result with a way to run or inspect it.[14]

For an asset-bearing task, add the material the agent needs to judge the result. The Ashen Crown developer said a unit task "needs a visual reference, dimensions, export requirements, and a way to check the result", and that "Make me an orc leaves too many decisions unresolved".[29] The asset guide's example brief shows a complete one.

Keep creative decisions explicit

For a design task, decide which parts are open for exploration. Ask for alternatives before implementation when the tradeoff is unclear:

Suggest three ways to make collecting objects more satisfying while
keeping the current controls and rules. For each, describe the player
effect and the implementation work. Do not change the project yet.

Choose a proposal, then make it a bounded implementation task, so a request for ideas does not become an unreviewed redesign. For visual work, say what must stay unchanged (composition, readable areas, palette, intentionally empty space). For a change that touches several established rules, ask for research and critique first: Willison's long design prompt for a new Battle Drones map included the instruction "First research and then critique this design. Only build after we have agreed on any modifications".[52]

Open-ended prompts can also work. Willison wrote that Battle Drones became "actually fun to play" after he told Claude Opus 5.5 to "Make it a LOT more fun" in an overnight run.[52] Others keep those calls for themselves: Thariq Shihipar wrote "don't outsource that to AI. Use AI to work with you to bring your vision to life", and the Just Farm developer said "I still made every taste call: how it feels, how it looks, what's fun."[25][28] Decide in advance which decisions a task delegates, and still review the result against the intended audience and rules.

Let the agent see and play the game

An agent that can only edit files cannot observe how its change looks or plays. Give it the evidence a human tester uses: screen captures, a way to provide input, logs and explicit tests. The GameDevBench authors introduced "two simple image and video-based feedback mechanisms" and reported that they consistently improved performance, raising GPT-5.4 from 41.1% to 52.0% in their setup.[58]

Give it eyes, hands and a judge

An agent needs what a human tester uses: a view of the screen, a way to give input, readable logs and runnable tests. In a browser game a browser tool supplies screenshots, and Claude Code's /verify builds and runs an app and looks at the result.[13] In an engine, these come from the command line or a bridge, and they differ by tool: Godot MCP, for example, has no input tool, so input must be scripted in the game or test code.[34] Each guide lists the documented capture, input, log and test tools: browser, Godot, Unity, Unreal Engine and, for Blender's multi-angle look tool, the Blender MCP article.

  1. Ask for evidence, not a claim. Anthropic's guidance is to ask for "the command it ran and its output, or the screenshot", because "All tests pass" on its own "tells you very little".[13] Put this requirement in the project instructions file.
  2. Inspect before and after. Capture the same view before and after a visual change and compare it with the approved reference. For Blender assets, the Ashen Crown developer described the loop as "the agent renders it, compares it with the concept, and revises it".[29]
  3. Drive the built game, not just the editor. The Just Farm runner "drives the built game to measure handling".[28] A measurement such as distance travelled during a fixed input interval is something an agent can check repeatedly; keep the build, input sequence and result.
  4. Let the game play itself. Battle Drones gained an "AI vs. AI" mode so Willison could watch the game "without having to directly control it myself", and during one overnight run, he wrote, Claude "ran over a thousand simulated playtest sessions, and used the results to rebalance the existing units".[52] Keep a bot scenario's seed and rules fixed during a comparison; bot results do not show whether people enjoy the game.
  5. Keep the simulation deterministic if replays, multiplayer or automated balance tests matter. Willison reported that Claude had to replace Math.sin() and Math.cos() because different browsers "returned very slightly different numbers", which desynchronized replays.[52] Test equivalent runs on each supported platform.
  6. Play it yourself. The Ashen Crown developer said: "The agents help automate checks and I still have to play and test the game myself."[29] Check clarity, timing and whether the intended interaction is satisfying.

Unattended and overnight runs

The Just Farm developer described the most automated workflow among these accounts: a runner script that takes one backlog card at a time "with a hard time and money budget per card", works in its own branch and "only lands the change if everything passes".[28] That is one developer's account, not a published tool. A comparable setup using documented features looks like this:

  1. Write cards. One task per file in a backlog folder, each with its acceptance checks, in the format of the asset or feature prompts above.
  2. Isolate each card. Create a branch or git worktree per card. Claude Code's --worktree option starts a session in an isolated worktree under .claude/worktrees/.[50]
  3. Run the agent non-interactively with caps. Claude Code's print mode (claude -p) accepts --max-budget-usd, --max-turns and --allowedTools; Anthropic notes that the budget cap is checked against a client-side estimate that "can differ from your bill".[50] The testing guide's headless agent runs section gives the flags and an illustrative call.
  4. Gate the merge on the engine's own checks. Build headlessly (unity build, or Godot's --headless --export-release), run the tests, and treat a test failure as final. Unity's CLI reference says a CI job should retry a failed unity test run "only exit code 6 or 7", never 8; an exit 6 can also mean the project is open in another Editor, which a retry will not fix.[38][56][70]
  5. Keep the evidence (screenshots, logs, the agent's report) next to the branch, and review before merging anything that changes game feel, art or rules, even when the checks pass.

Keep a wall-clock stop in the runner as well as the agent's own caps.

Debug with evidence

Give the assistant a reproducible observation rather than only "the game is broken": the engine and package versions and device, the starting state, the exact reproduction steps (for example, start a run, collect one object, lose, then restart), the expected result (score is zero), the actual result (score still shows one), the log, stack trace or capture, and the commit after which the behavior appeared. Ask it to investigate the existing logic, explain the cause and propose the smallest relevant fix. After applying it, repeat the reproduction and an adjacent case, such as restarting after a win, and record what was actually tested: a plausible explanation or a generated test file is not a passed check. If the assistant cannot observe a scene, device or build process, perform that check directly.

Systems that need extra care

Save data, multiplayer and mobile builds fail in ways a quick local play session does not show. Give each its own acceptance check.

  • Save data. An agent that renames a saved field can break old saves while every new-game test passes. This guide recommends a format version in every save, a migration for each format change and a save from each released build kept as a test fixture, required by a line in the project instructions. See browser, Godot, Unity, Unreal and release checks.
  • Multiplayer. Decide which machine owns each value before the agent writes networking code, ask for a test in which the server refuses a forbidden client request, and run a host and at least two clients. See browser, Godot, Unity, Unreal, Roblox and release checks.
  • Mobile builds. Desktop emulation and simulated touch are not a phone, so this guide recommends a real-device run in every mobile acceptance check; keep signing keys and store uploads with a person, and plan for store beta waiting periods. See browser, Godot, Unity, Unreal and store betas.

Bring generated assets into a production pipeline

Full guide: Creating Game Assets with AI.

An image or mesh that looks convincing in a generator still has to work inside the game. Write the asset brief before generating (purpose, view, style references, technical target, budget) and inspect the imported result in the intended camera, lighting and interface; the full guide covers sprites, meshes, audio and dialogue, import settings, an example brief and acceptance checks. Import settings matter: Godot's documentation, for example, distinguishes disk compression from video-memory use for images,[15] and documents format-specific tradeoffs for audio.[17]

A concrete 3D pipeline

The two most detailed public accounts, Just Farm (Unity) and Ashen Crown (Unreal), follow similar stages; tool capabilities are each vendor's own description:[28][29]

  1. Concept. Generate concept images, pick one and keep accepted images as references; Just Farm used Magnific.[28]
  2. Model. Turn the concept into a mesh with a generator such as Tripo, Meshy, Hunyuan 3D or TRELLIS.2, or have the agent build it in Blender with Python.[63][64][60][61] Check shape and triangle budget.
  3. Clean up in Blender, optionally driven by MCP for Blender: Just Farm used "Blender + MCP, driven by scripts, to clean up, split, rescale and fix those models".[28][45]
  4. Rig and animate, for example with Mixamo's automatic rigging and animation library.[62]
  5. Export and import in a format the engine supports (glTF 2.0 is Godot's recommendation),[16] then check scale, orientation, materials and movement in the game: "This is where the asset has to prove itself", in the Ashen Crown developer's words.[29]

The Ashen Crown developer took rocks, ground and trees from Poly Haven scans rather than modelling them, and judged art "from the camera you play with".[29] The asset guide's two published workflows and generator tables give the details.

For 2D sprites, Willison gave Claude Code for Web an OpenAI API key in an environment variable and told it to use OpenAI's image generation API; he wrote that Claude "can view the images it has generated and iterate on the prompts".[52] Keep such keys out of the repository.

Keeping a consistent style

Accept a small reference set before generating a large batch, attach it to every asset task, and review related assets side by side in the engine. Where you have suitable source art and permission to use it, Scenario advertises custom model training and an MCP integration for coding agents.[65] See the asset guide's style section.

Record provenance and check terms

Record the generator, model, date, reference inputs, applicable terms, edits and whether the file is a placeholder or intended for release, and check the rights to inputs as well as outputs. Unity's AI principles, for example, place responsibility for appropriate use and third-party rights on the user.[18] Terms differ sharply: Poly Haven's assets are CC0,[59] Tencent's Hunyuan 3D 2.0 licence excludes the European Union, the United Kingdom and South Korea,[60] and TRELLIS.2's MIT licence does not cover its nvdiffrast and nvdiffrec dependencies.[61] The asset guide's provenance record covers more. Do not assume that access to a fan project's assets, a recognizable character or a generated imitation grants permission to redistribute it.

Test the build, the experience and the performance

Full guide: Testing and Releasing AI-Assisted Games.

Compile checks, logic tests, engine tests, visual inspection, external playtests, profiling and an exported-build smoke test answer different questions. Unity Test Framework separates Edit Mode and Play Mode tests;[19] Unreal Engine documents automation for unit, feature and content-stress testing, along with screenshot comparisons.[20] Give an assistant the test facilities that actually exist in the project, rather than accepting an invented test command. The engine guides give the command-line forms; put the commands that work in the instructions file so the agent runs the same checks a person would.

Play the game after changing movement, animation, collision or input. For performance, capture a representative slow scene before asking for optimization (Godot's profiler reports frame, physics and script timings[21]), change one suspected cause and compare equivalent runs. Test an export early, because distribution builds have their own packaging rules.[22]

If the game uses a model during play

Treat runtime generation as a separate feature with its own acceptance criteria. Decide what happens when a request is slow, fails, returns unsuitable output or exceeds a budget. Keep game rules and authoritative state in code, and validate model output before it changes inventory, awards items or charges an account. No prompt or moderation setting prevents every failure. Adding Generative AI Features to Games covers where the model runs, fallbacks, latency, cost, moderation, privacy and store rules.

Estimate usage from the actual interaction design. For a hypothetical text service with 1,000 players making 20 requests each, at 800 input tokens and 200 output tokens per request, the workload is 16 million input tokens and 4 million output tokens. If the provider charges p_in and p_out per million tokens, the token-only estimate is 16 * p_in + 4 * p_out. It excludes retries, extra calls, caching, hosting and other services; substitute measured usage and current rates.

Costs and usage limits

Development cost and runtime cost are separate budgets. Development cost is what the coding agent and asset generators consume while the game is made; runtime cost is what players' sessions consume after release (see the worked example above).

For development, the main choice is between a subscription and pay-per-token API billing. Anthropic's documentation says Claude Code "charges by API token consumption", while Pro and Max subscribers "have usage included in their subscription" and see plan usage bars in /usage; usage credits can extend a subscription past its plan limit. Anthropic also reports that across enterprise deployments "the average cost is around $13 per developer per active day and $150-250 per developer per month", figures for those deployments rather than a game-development budget.[51] Limits and resets vary by provider and plan; see AI usage limits.

Developer accounts give a sense of scale, though none is an audited budget:

ProjectWhat the developer reported about usage
Ashen Crown"3.5 weeks and 23.1 billion tokens"; the creator said they were happy to use Claude Code on a subscription "and not pay the API prices"[29]
Battle DronesUltracode "burns tokens like there's no tomorrow"; one version exists because Willison had "only used 75% of my weekly allowance and it was resetting in 45 minutes"[52]
Quarter Sun CoveWillison had Opus 5.5 Ultracode "burn millions of tokens and nearly two days building it"[53]
Just Farm"a hard time and money budget per card" for each unattended task[28]

Expanded article table

Practical controls:

  • Match the model to the task. The Ashen Crown developer used "Claude Code with Opus 5.5 as orchestrator and Sonnet 5.5 for clearly defined features".[29] Treat that as one creator's workflow and compare options on your own project.
  • Prefer cheap channels to the engine. Unity says its direct CLI commands use fewer tokens than MCP,[36] and Epic's Unreal MCP defaults to a tool-search mode that keeps responses small.[43]
  • Count asset generation separately. Image and 3D services bill on their own plans or credits.
  • Plan hosting. A static browser game can be served from services such as GitHub Pages; Willison estimated that his Battle Drones WebSockets relay on a single Fly.io shared-cpu-1x instance "should cost me no more than $2.19/month", an estimate for his stated setup only.[53][52]

Common mistakes and fixes

Rows marked "general advice" are this guide's recommendations; the others cite the source that describes the problem or the fix.

SymptomLikely causeFix
The agent says a feature works, but it does not in playIt edited files without running or seeing the gameConnect an engine bridge or browser tool and require the command output or screenshot in every report[13][58]
Interface screens are clutteredAgents tend to add detail; Shihipar wrote that "one of my frustrations of UI with agents is that it adds too many details"[26]State what to leave out, give one reference screen, and review one screen at a time (general advice)
A one-prompt game looks right but is not funRules and feel were never tested or iteratedWork in bounded increments and play each one; Willison's first Battle Drones version "wasn't any fun to play"[52]
Two editors interfereTwo projects or MCP servers on one portUse the per-project URL Funplay's window shows; give each extra Blender instance its own port (--port) and run one client per server[40][45]

Expanded article table

Prepare for distribution and public feedback

Full guide: Testing and Releasing AI-Assisted Games.

Review the actual release build and store materials, including retained generated art, audio and text, and describe how AI was used accurately. A platform's rules, a community's posting rules and a generator's terms answer different questions.

As checked on 30 October 2026, Steam's Content Survey says its generative AI section is "concerned with the use of AI in creating content that ships with your game, and is consumed by players", not with efficiency gains from AI tools; GameSpot reported the revision on 19 January 2026.[5][66] For live-generated content, developers must also describe the "guardrails" that keep the AI from generating illegal content.[5] itch.io asks creators to use its AI Disclosure field accurately; its statement about strict enforcement addresses game asset pages.[23] See the testing guide's release materials and Steam AI disclosure.

What the research establishes

A 2025 qualitative synthesis of ten studies by Ternar and colleagues found continued human refinement and pipeline integration to be recurring themes, while efficiency claims were contested; it is not a controlled estimate of how much faster a project will ship.[24] A 2026 exploratory preprint tested GPT-4o on six tasks in one Python/Pygame endless runner: three selected refactorings worked, but only one of three gameplay additions integrated correctly, and the two failures passed unit tests while failing manual gameplay assessment. The authors caution that one project does not establish general model performance.[33] A September 2026 survey by Luo and colleagues argues that capabilities and outputs need validation in their target game context.[1] Together these support keeping compilation, gameplay correctness, asset suitability, performance and player experience as separate checks.

The GameDevBench paper (ICML 2026) evaluates 333 tasks derived from web and video tutorials. In its tested configurations the best agent and method solved 53.8% of tasks, with lower success on 2D graphics tasks than on gameplay-oriented ones.[58] The authors' separate leaderboard, which adds later evaluations, listed a top pass@1 score of 70.6% (claude-opus-5.5 in Claude Code) as of 30 October 2026.[71] A score applies to its model, harness, feedback and task set; it does not show whether an assistant will finish a different game. The practical measure is an assistant's contribution to a reviewed, working project, so keep your own records of time spent implementing, checking and repairing changes.

Developer examples and community resources

The projects quoted in this guide are reported workflows and prototypes, not controlled comparisons or audited budgets: Pieter Levels's browser flight simulator fly.pieter.com,[54] Simon Willison's Battle Drones, which he calls "heavily vibe coded",[52] Thariq Shihipar's fighting-game prototype,[25][26] Just Farm, a Unity game by Dasi Games,[28][55] and Ashen Crown, an unofficial fan RTS in Unreal Engine 5.[29] The case studies in AI game development compare them. See also vibe coding.

For sharing work and asking workflow questions, r/aigamedev and r/TopologyAI are relevant communities. Read their current rules and explain what was made, how and what feedback is needed; they are discussion venues, not authorities on technical correctness or distribution rights.[30][31]

Continue reading

More to read

Topics:AI in GamingDeveloper ToolsGenerative AISoftware Development

References

  1. ^Luo, Meng, et al. AI for Games in the Foundation Model Era. arXiv preprint, 15 September 2026.
  2. ^Godot Engine. Your first 2D game. Stable documentation.
  3. ^Phaser. Making your first Phaser Game. Official tutorial.
  4. ^Epic Games. Behavior Trees in Unreal Engine. Unreal Engine documentation.
  5. ^1 ^2 ^3Valve. Content Survey. Steamworks documentation, Generative Artificial Intelligence Content section. Checked 30 October 2026.
  6. ^Phaser. What is Phaser?. Official documentation.
  7. ^Godot Engine. Nodes and Scenes. Stable documentation.
  8. ^Unity. Unity's AI tools. Official documentation. Checked 30 October 2026.
  9. ^Epic Games. Introduction to Blueprints. Unreal Engine documentation.
  10. ^1 ^2Unity. About Unity's plugin. Official documentation.
  11. ^Godot Engine. Version control systems. Stable documentation.
  12. ^GitHub. Application card: GitHub Copilot inline suggestions. Responsible-use documentation.
  13. ^1 ^2 ^3 ^4 ^5Anthropic. Best practices for Claude Code. Official documentation.
  14. ^de Oliveira, Delba. Building verification loops in Claude Code with skills. Anthropic.
  15. ^Godot Engine. Importing images. Stable documentation.
  16. ^Godot Engine. Available 3D formats. Stable documentation.
  17. ^Godot Engine. Importing audio samples. Stable documentation.
  18. ^Unity. Unity AI Guiding Principles. Checked 30 October 2026.
  19. ^Unity. Edit Mode vs. Play Mode tests. Unity Test Framework 1.4.6 documentation.
  20. ^Epic Games. Automation Test Framework. Unreal Engine documentation.
  21. ^Godot Engine. The Profiler. Stable documentation.
  22. ^Godot Engine. Exporting projects. Stable documentation.
  23. ^itch.io. Content creator quality guidelines. AI disclosure section. Checked 30 October 2026.
  24. ^Ternar, Alexandru, et al. Generative AI in Game Development: A Qualitative Research Synthesis. arXiv, version 2, 9 December 2025.
  25. ^1 ^2Thariq Shihipar (@trq212). Thread on prototyping a video game. X, 30 September 2026.
  26. ^1 ^2Thariq Shihipar (@trq212). Post on "vibe UI" explorations for an elemental fighting game. X, 29 October 2026.
  27. ^1 ^2 ^3 ^4 ^5Anthropic. How Claude remembers your project. Claude Code documentation (CLAUDE.md and AGENTS.md). Accessed 30 October 2026.
  28. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10u/SirKnighty. My game got removed from gamedev subs for using AI, so here's exactly how I made it. r/accelerate, Reddit, developer account. Checked 30 October 2026.
  29. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9 ^10Coding Crash Courses. Ashen Crown workflow showcase. YouTube, 12 October 2026. Video description and narration (auto-generated captions) identify the unofficial fan project and its reported workflow; creator-reported figures remain unaudited.
  30. ^Reddit. r/aigamedev. Community description and rules. Checked 30 October 2026.
  31. ^Reddit. r/TopologyAI. Community description and rules. Checked 30 October 2026.
  32. ^Gallotta, Roberto, et al. Large Language Models and Games: A Survey and Roadmap. IEEE Transactions on Games, 2024; arXiv version 5, 9 December 2024.
  33. ^Wunderlich, Jan, Markus Kleffmann and Sebastian Lempert. An Exploratory Case Study of LLM-Assisted Refactoring and Gameplay Feature Generation in an Endless Runner Game. arXiv preprint, 19 June 2026.
  34. ^1 ^2 ^3Coding-Solo. Godot MCP. GitHub README, MIT license. Accessed 30 October 2026.
  35. ^1 ^2 ^3Unity Technologies. Use the Unity command-line interface (CLI). Unity documentation. Accessed 30 October 2026.
  36. ^1 ^2 ^3Unity Technologies. Unity CLI as the replacement for the in-Editor MCP server. Unity documentation. Accessed 30 October 2026.
  37. ^1 ^2 ^3 ^4Unity Technologies. Unity's plugin for Claude Code. Unity documentation. Accessed 30 October 2026.
  38. ^1 ^2 ^3Unity Technologies. Unity CLI reference. Unity documentation (commands and exit codes); CLI release 1.0.0-beta.14, 21 October 2026. Accessed 30 October 2026.
  39. ^Unity Technologies. Unity Pipeline package. Unity documentation. Accessed 30 October 2026.
  40. ^1 ^2 ^3 ^4FunplayAI. Funplay MCP for Unity. GitHub README (version 0.7.3), MIT license. Accessed 30 October 2026.
  41. ^1 ^2CoplayDev. MCP for Unity. GitHub README (v10.0.0), MIT license. Accessed 30 October 2026.
  42. ^Ivan Murzak. Unity-MCP. GitHub README. Accessed 30 October 2026.
  43. ^1 ^2 ^3Epic Games. Unreal MCP in Unreal Editor. Unreal Engine 5.8 documentation (Experimental feature). Accessed 30 October 2026.
  44. ^1 ^2 ^3chongdashu. unreal-mcp. GitHub README (experimental), MIT license. Accessed 30 October 2026.
  45. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9ahujasid. MCP for Blender (formerly blender-mcp). GitHub README, MIT license. Accessed 30 October 2026.
  46. ^1 ^2 ^3 ^4 ^5Blender Lab. MCP Server. blender.org. Accessed 30 October 2026.
  47. ^1 ^2 ^3Anthropic. Connect Claude Code to tools via MCP. Claude Code documentation. Accessed 30 October 2026.
  48. ^AGENTS.md. Project site for the AGENTS.md format. Accessed 30 October 2026.
  49. ^1 ^2 ^3 ^4Anthropic. Configure permissions. Claude Code documentation. Accessed 30 October 2026.
  50. ^1 ^2Anthropic. CLI reference. Claude Code documentation. Accessed 30 October 2026.
  51. ^Anthropic. Manage costs effectively. Claude Code documentation. Accessed 30 October 2026.
  52. ^1 ^2 ^3 ^4 ^5 ^6 ^7 ^8 ^9Simon Willison. Battle Drones: a vibe coded RTS with audio-based multiplayer. Simon Willison's Weblog, 20 October 2026.
  53. ^1 ^2 ^3 ^4Simon Willison. The October inflection point for vibe game development. Simon Willison's Weblog, 28 October 2026.
  54. ^Pieter Levels (@levelsio). Post announcing fly.pieter.com. X, 22 February 2025.
  55. ^Dasi Games. Just Farm. Steam store page, including its AI Generated Content Disclosure. Accessed 30 October 2026.
  56. ^1 ^2Godot Engine. Command line tutorial. Stable documentation. Accessed 30 October 2026.
  57. ^Phaser. Installing. Official documentation. Accessed 30 October 2026.
  58. ^1 ^2 ^3Wayne Chi et al. GameDevBench: Evaluating Agentic Capabilities Through Game Development. Proceedings of ICML 2026, PMLR 306:19395-19423; first preprint 11 February 2026.
  59. ^Poly Haven. License. Accessed 30 October 2026.
  60. ^1 ^2Tencent Hunyuan. Tencent Hunyuan 3D 2.0 Community License Agreement. GitHub. Accessed 30 October 2026.
  61. ^1 ^2Microsoft. TRELLIS.2. GitHub README (Native and Compact Structured Latents for 3D Generation), MIT license. Accessed 30 October 2026.
  62. ^Adobe. Mixamo. Product site. Accessed 30 October 2026.
  63. ^Tripo. Tripo AI 3D model generator. Product page. Accessed 30 October 2026.
  64. ^Meshy. AI 3D Model Generator. Product page. Accessed 30 October 2026.
  65. ^Scenario. Scenario: AI for creative production and game assets. Archived product page, 17 October 2026.
  66. ^Alessandro Barbosa. Valve Updates AI Disclosure Guidelines To Allow For AI-Powered Tools. GameSpot, 19 January 2026.
  67. ^CVE Program. CVE-2026-10688 record. Published 2 June 2026.
  68. ^GitHub Advisory Database. BlenderMCP path traversal in download_polyhaven_asset allows arbitrary file writes (CVE-2026-66004, GHSA-4h8q-hh2j-755w). Published 24 July 2026.
  69. ^Unity Technologies. Unity command-line interface (CLI). Official documentation, Experimental status. Accessed 30 October 2026.
  70. ^1 ^2Unity Technologies. Run, test and build: Unity CLI command reference. Official skills repository. Accessed 30 October 2026.
  71. ^GameDevBench authors. GameDevBench project and leaderboard. Accessed 30 October 2026.
  72. ^1 ^2 ^3 ^4 ^5 ^6Phaser. Phaser Vite Template. Official template repository (README, `package.json`, `.gitignore` and `vite/config.prod.mjs`). Accessed 30 October 2026.
  73. ^1 ^2 ^3Phaser. Using the Create Phaser Game app. Official tutorial, 2 April 2024; page, including its note for AI agents, as served 30 October 2026.
  74. ^1 ^2Phaser Studio. create-game: questionsText.ts. Source of the Create Phaser Game app, version 1.3.2 (installer prompts and closing message). Accessed 30 October 2026.
  75. ^1 ^2Anthropic. Quickstart. Claude Code documentation. Accessed 30 October 2026.
  76. ^OpenAI. Codex CLI. OpenAI developer documentation. Accessed 30 October 2026.
  77. ^OpenAI. Custom instructions with AGENTS.md. Codex documentation. Accessed 30 October 2026.
  78. ^Scott Chacon and Ben Straub. First-Time Git Setup. *Pro Git*, 2nd edition. Accessed 30 October 2026.
  79. ^Scott Chacon and Ben Straub. Getting a Git Repository. *Pro Git*, 2nd edition. Accessed 30 October 2026.
  80. ^1 ^2Scott Chacon and Ben Straub. Recording Changes to the Repository. *Pro Git*, 2nd edition. Accessed 30 October 2026.
  81. ^1 ^2 ^3Microsoft. Installation. Playwright documentation. Accessed 30 October 2026.
  82. ^Microsoft. Web server. Playwright documentation. Accessed 30 October 2026.
  83. ^Vite. Command Line Interface. Official documentation (`vite preview`). Accessed 30 October 2026.
  84. ^itch.io. Uploading HTML5 games. Creator documentation. Accessed 30 October 2026.
  85. ^itch.io. Controlling who can access your project. Creator documentation. Accessed 30 October 2026.
  86. ^1 ^2 ^3Naavik (Matthew Camp). Prompt-to-Game Is Here. Which Platforms Are Positioned to Win?. Industry analysis, 27 October 2026; accessed 30 October 2026.
  87. ^Google Labs. Playground. Product page; accessed 30 October 2026.
  88. ^1 ^2Google. Playground Help Center. Help page, archived copy of 15 October 2026 (the live page now requires sign-in); accessed 30 October 2026.
  89. ^Google. Playground Additional Terms of Service. Terms, last modified 20 September 2026 (archived copy of 7 October 2026); accessed 30 October 2026.
  90. ^Unity Technologies. Unity Spark. Product page; accessed 30 October 2026.
  91. ^GamesIndustry.biz (Lewis Packwood). Unity unveils a web-based AI game creation platform. News article, 7 October 2026; accessed 30 October 2026.
  92. ^Y Combinator. Rosebud AI. Company directory entry; accessed 30 October 2026.
  93. ^Rosebud AI. AI game maker. Product page; accessed 30 October 2026.
  94. ^Rosebud AI. Rosebud AI Pricing. Pricing page and FAQ; accessed 30 October 2026.
  95. ^Rosebud AI. Terms of Service. Terms, last revised 2 August 2025; accessed 30 October 2026.
  96. ^GamesBeat (Dean Takahashi). Astrocade hits 10M monthly players for its AI-assisted UGC casual games platform. News article, 7 October 2026; accessed 30 October 2026.
  97. ^Astrocade. Astrocade MCP. Setup page; accessed 30 October 2026.
  98. ^Roblox. Build Without Limits on Roblox. Newsroom announcement, 16 July 2026; accessed 30 October 2026.
  99. ^Meta for Developers. Meta Connect Recap: Sign Up for Early Access to Horizon Create and Horizon Studio. Developer blog, 24 September 2026; accessed 30 October 2026.
  100. ^GameMaker. GML Code. GameMaker Manual; accessed 30 October 2026.
  101. ^1 ^2Opera. GameMaker launches GMRT: The runtime professional developers have been waiting for. Press release, 30 April 2026; accessed 30 October 2026.
  102. ^YoYo Games. gm-cli README. GitHub repository (Apache 2.0); accessed 30 October 2026.
  103. ^Game Developer (Chris Kerr). GameMaker incorporates Claude Code to enable AI-assisted workflows. News article, 30 April 2026; accessed 30 October 2026.
  104. ^Bevy. Bevy Engine. Official website; accessed 30 October 2026.
  105. ^GameFromScratch. BEVY 0.5 Rust Game Engine Released. News article, 7 April 2021; accessed 30 October 2026.
  106. ^Bevy. Bevy 0.15. Release notes, Bevy Remote Protocol section, 29 November 2024; accessed 30 October 2026.
  107. ^Bevy. Module bevy::remote. API documentation on docs.rs; accessed 30 October 2026.
  108. ^natepiano. bevy_brp_mcp README. GitHub repository (community project, MIT or Apache 2.0); accessed 30 October 2026.
  109. ^Defold Foundation. Defold LLM documentation index. Official documentation index; accessed 30 October 2026.
  110. ^Windows Central (Adam Hales). Xbox just gained support for another game engine, making it easier for developers to bring their games to Microsoft's consoles. News article, 13 October 2026; accessed 30 October 2026.
  111. ^Defold Foundation. Using AI coding agents with Defold. Defold manual; accessed 30 October 2026.
  112. ^GamingOnLinux. Open source cross-platform event-driven game engine 'GDevelop' now on itch, progressing well. News article, November 2018; accessed 30 October 2026.
  113. ^GDevelop. GDevelop. Official website; accessed 30 October 2026.
  114. ^GDevelop. Build and learn with GDevelop AI. GDevelop documentation; accessed 30 October 2026.
  115. ^GDevelop. Use Claude Code, Cursor, Codex or other AI agents with GDevelop (MCP). GDevelop documentation; accessed 30 October 2026.
  116. ^Roblox. Assistant for Studio. Creator Hub documentation; accessed 30 October 2026.
  117. ^Roblox. Connect to the Roblox Studio MCP server. Creator Hub documentation; accessed 30 October 2026.
  118. ^1 ^2Roblox (David Baszucki). RDC 2026: The World Needs More Play. Newsroom announcement, 11 September 2026; accessed 30 October 2026.
  119. ^Vite. Preview Options. Official documentation (`preview.port`). Accessed 30 October 2026.
  120. ^1 ^2kodasdream. The GameFeel Benchmark: README and methodology. Maintainer's task descriptions, grading and billing fields. Accessed 17 November 2026.
  121. ^1 ^2kodasdream. GameFeel dashboard source, `app.js`. Warning labels and task-price display logic. Accessed 17 November 2026.

Improve this article

Add missing citations, update stale details, or write a clearer explanation. Anyone can edit: changes go live when you publish, and every edit is checked by an editor.

8 revisions · v8 · 11,030 words · full history

Fact-checks are independent of edits: a reviewer re-verifies the article against its sources and stamps the date. How we verify

Research and drafting on this wiki are AI-assisted, under named human editorial standards. How AI is used here

Reviewer note: Independent two-verifier pass on phase-4 changes (xg28 VP_hubA+VP_hubB): 1 material (Vite preview port/address) + 9 minor fixed before publish

Cite this page: AI Wiki. "Developing Games with AI." aiwiki.ai, updated 17 Nov 2026, fact-checked 30 Oct 2026. CC BY 4.0. https://aiwiki.ai/wiki/developing_games_with_ai

Edit article