# Testing and Releasing AI-Assisted Games

> Source: https://aiwiki.ai/wiki/testing_and_releasing_ai_assisted_games
> Updated: 2026-10-30
> Fact-checked: 2026-10-30
> Categories: AI Code Generation, AI in Gaming, Developer Tools, Software Development
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "Testing and Releasing AI-Assisted Games." aiwiki.ai, 30 Oct 2026. https://aiwiki.ai/wiki/testing_and_releasing_ai_assisted_games
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**Testing and releasing AI-assisted games** means checking the project and the distributed build against written requirements, then preparing an accurate release. An assistant can help write tests, reproduce failures and assemble evidence. The developer still needs to decide whether the result meets the game's design and release criteria. In research on game development, executable behavior and visual presentation are distinct evaluation targets.[1][2]

This practical guide is part of [Developing Games with AI](https://aiwiki.ai/wiki/developing_games_with_ai). Its checklists and sample records are recommended working methods, not a certification scheme or a guarantee that an automated test suite will find every defect. Adapt them to the features and platforms the game actually supports. The guide is engine-neutral: engine commands and bridges are covered in the [browser](https://aiwiki.ai/wiki/developing_browser_games_with_ai), [Godot](https://aiwiki.ai/wiki/developing_godot_games_with_ai), [Unity](https://aiwiki.ai/wiki/developing_unity_games_with_ai) and [Unreal Engine](https://aiwiki.ai/wiki/developing_unreal_engine_games_with_ai) guides. Platform rules quoted below were checked on 30 October 2026 and can change.

## Define what must work

Start with the rules players should observe. A request to check whether a game is good leaves the assistant without a reliable pass condition. A requirement such as "collecting the same token cannot increase the score twice" can be checked directly.

For each feature, record its initial state, action and expected outcome. Include transitions as well as the first successful run. Restarting after a loss, leaving a menu, loading a saved game or returning from another application can expose state that the original implementation never resets.

| Requirement | Example evidence | Separate question |
| --- | --- | --- |
| The project builds | Build command, exit status and log | Does the exported game launch? |
| A pickup counts once | Recorded score before and after repeated overlap | Does the player understand the pickup? |
| Restart resets the round | State assertions and a second completed round | Does restart feel responsive? |
| The interface is readable | Review at intended sizes and display conditions | Can players use the available controls? |
| A generated model fits the scene | Imported mesh, materials, collision and animation checks | Is its origin and permitted use recorded? |
| A runtime service can fail safely | Deliberately induced failure with the expected fallback | Is ongoing service usage sustainable? |

Choose release blockers before testing. For a small collect-and-avoid prototype, inability to start, incorrect win or loss rules, an unusable restart, or a missing required asset could block sharing the build. Cosmetic problems can be recorded separately. These priorities are project decisions, not universal severity definitions.

## Preserve the build and its context

Record the commit, engine and package versions, target platform, build configuration and command used. Retain the resulting artifact with its test results. A report against a development scene is not automatically a report against the later package uploaded to a store.

Start the candidate from a clean launch with the assets it actually contains. Do not assume that a local editor cache, an absolute file path or a service credential on the developer's machine will exist for another player. Godot's export documentation, for example, describes export presets and templates as well as the selection of project resources.[3] It also notes that `.godot/export_credentials.cfg`, which holds confidential export options, is normally kept out of version control, so a fresh clone or CI machine can be missing those options.[3]

Keep generated assets and their provenance records together. [Creating Game Assets with AI](https://aiwiki.ai/wiki/creating_game_assets_with_ai) covers the production checks. Before release, identify which files remain placeholders, which generated outputs ship, and which inputs or dependencies have conditions the project must meet. A test result does not establish permission to distribute a file.

Use a fixed test scenario when comparing builds: the same scene, starting state, input sequence and relevant settings. If randomness matters, record the seed or retain enough state to reproduce the run. A reproducible scenario makes a proposed fix easier to assess than an unexplained screenshot of a different encounter.

## Use several kinds of checks

Compilation, unit tests, engine integration, visual inspection and human playtesting answer different questions. Choose the least expensive useful check for each failure, then exercise the feature in the running game.

![Preserve a candidate build, run rule and integration checks, review visuals and human play, then test the exported artifact and release materials.](/images/game-guide-release-evidence-20a40ddc41ca.svg)

*A passing check answers a specific question. Retain evidence for the candidate, review the player experience and test the exported game before release.*

| Layer | Suitable checks | What a pass leaves unresolved |
| --- | --- | --- |
| Source and dependencies | Parsing, compilation, type checks and dependency inspection | Runtime behavior and presentation |
| Game rules | Unit tests for score, inventory, transitions or cooldowns | Correct integration with scenes and input |
| Engine integration | Instantiation, references, signals or events, physics interactions | The complete player experience |
| Visual output | Captures of a known scene and review against a reference | Whether the rules work during interaction |
| Exported build | Launch, assets, controls, save behavior and complete play loop | Performance on untested devices |
| Human playtest | Observed understanding, difficulty and interaction problems | Exhaustive coverage of possible states |

Unity Test Framework distinguishes Edit Mode tests, which run in the Editor and can access Editor code, from Play Mode tests that can exercise runtime behavior.[4] Unreal's automation framework provides unit, feature and content stress tests, with additional interfaces for input simulation, functional tests and screenshot comparisons.[5] For a browser game, use the browser's observations and an appropriate test runner as described in [Developing Browser Games with AI](https://aiwiki.ai/wiki/developing_browser_games_with_ai).

Use commands for the installed engine and integration. An engine bridge may expose a different route from a separate batch process. For example, the current Unity CLI documentation says its `unity test` command starts a batch Editor; the project must not already be open in another Editor. Its Pipeline tools offer a route for tests in an existing Editor after checking that Play Mode is stopped.[6] Do not paste a generic command into a running project and interpret a setup failure as a failed gameplay test.

## Let an agent playtest the build

An agent that only edits files cannot observe what its change does on screen. Give it three channels into the running game, and keep their outputs as evidence:

| Channel | What it provides | Where the engine-specific tools are described |
| --- | --- | --- |
| Simulated input | Key presses, clicks, touches or a scripted bot that plays a fixed scenario | Browser test runners, engine bridges and automation drivers in the engine guides; the hub's [tool table](https://aiwiki.ai/wiki/developing_games_with_ai) |
| Screenshots or recordings | The state of a known scene at a known moment | Godot's `--write-movie` with `--fixed-fps` and `--quit-after`; screenshot tools in browser and engine bridges[27] |
| Logs and state output | Console errors, assertions, scores and timings printed by the game or test | The engine's log, test reports and the game's own debug output |

Godot's command line shows how a capture can be made repeatable: `--write-movie <file>` forces a fixed frame rate (which `--fixed-fps` can change), and `--quit-after` sets the number of frames to write.[27] A fixed frame rate removes one source of variation between runs; it does not by itself make the game logic deterministic.

Two public accounts show the pattern at different scales. Simon Willison wrote that, during one overnight Claude Code run on his browser RTS Battle Drones, Claude "ran over a thousand simulated playtest sessions, and used the results to rebalance the existing units, add new ones, and introduce new features." Release notes that Claude wrote for that version reported that in 1,200 AI-vs-AI test matches, games still undecided after 25 minutes fell from 14% to 0.9%.[17] These are agent-written figures from a hobby project, not an audited balance study. The same post records two limits of automated play: Claude had to replace `Math.sin()` and `Math.cos()` with custom versions because Chrome and Safari returned slightly different numbers and desynchronized replays, and a human playtest found that the audio-based multiplayer mode gave his wife "a nasty headache", which led to a warning and a WebSockets alternative.[17][43] The developer of Just Farm, posting on Reddit as u/SirKnighty, described a runner that "builds the game headlessly, runs tests, drives the built game to measure handling, takes screenshots, and only lands the change if everything passes." The same account says the developer "still made every taste call".[18]

The following illustrative prompt asks an agent to playtest rather than to fix. Replace the bracketed parts with the project's own commands and cases.

```text
Playtest only. Do not change game code or assets.
Build: [command that produces the candidate build]
Launch: [command or URL for the built game, not the editor]
Cases: run each case in tests/ACCEPTANCE.md in order.
For each case:
- Use the documented input route [bot script, test runner or bridge tool].
- Capture a screenshot at the step named "capture" in the case.
- Copy the relevant log lines and any assertion output.
- Record pass, fail, blocked or not run, with the reason.
Write the results to reports/[date]-playtest.md.
Stop and report if the build fails or the game does not launch.
```

Asking for a report before a fix keeps the first failure intact. A separate task can then reproduce one failing case and propose a bounded change, as described below.

## Write an acceptance record before asking for a fix

The following is an illustrative test record for the small prototype used throughout the series. Its numbers and rules are design choices.

```text
Case: restart_after_loss
Build: [commit and artifact identifier]
Environment: [device, OS, engine/browser and display settings]
Initial state: a new round with five tokens and score zero
Actions:
1. Collect one token.
2. Touch the hazard.
3. Activate Restart.
Expected:
- Score is zero.
- All five tokens are available again.
- Player and hazard return to their starting state.
- The next token can be collected exactly once.
Actual: [observed result]
Evidence: [log, state assertion, capture or recording]
Status: pass / fail / blocked / not run
```

Ask the assistant to reproduce the failure, inspect the responsible code and propose a bounded change. After the patch, rerun the original case and nearby cases, such as restarting after a win and restarting more than once. Review the diff for changes to unrelated rules.

Keep a check's execution outcome separate from its finding. "Blocked because the export template is missing" is useful information; it is not a gameplay pass. A generated test that has never run belongs in the report as unexecuted work. Preserve the first failure rather than repeatedly rerunning until one attempt passes without explaining the difference.

## Use screenshots and replays carefully

A screenshot comparison can reveal a missing HUD, changed layout or material regression in a controlled scene. Playwright supports comparison with retained reference screenshots and warns that rendering varies with the operating system, browser, hardware and other conditions.[7] Run comparisons in a consistent environment. Inspect intentional visual changes before accepting a new baseline.

Make the scenario stable enough to compare. Fix the camera, scene state and relevant randomness; capture a meaningful point in the interaction. Decide which animated or time-dependent regions need separate checks. Raising a screenshot tolerance until a failure disappears can conceal a genuine regression.

A replay is useful when it reaches the state being tested. Assert the resulting score, objective, inventory or transition where the game provides an appropriate interface. Watching a bot move through a room is not evidence that it satisfied an unobserved win condition. A visual judge can supplement those checks, but its description can also be wrong.

The September 2026 SWE-Game preprint evaluates 247 tasks grounded in 41 Godot reference games. Its evaluation combines runtime checks, input replay and demonstrations with separate visual assessment. These are results for a particular research setup, not a certification of arbitrary games or current assistants.[1] On behaviors that humans had labeled in 100 agent-built games, the authors report 92.59% balanced accuracy for their executable checks against 78.41% for a video-based vision-language judge.[1] The June 2026 GameCraft-Bench preprint similarly evaluates complete Godot artifacts through interaction, rather than treating a plausible source tree as sufficient.[2]

## Run checks unattended and in CI

Automation repeats the checks a person already trusts; it does not decide what to check. Keep the acceptance cases in the repository, run them the same way every time, and make every unattended job stop on its own.

### Headless agent runs with Claude Code

[Claude Code](https://aiwiki.ai/wiki/claude_code) runs non-interactively with `-p` (`--print`). The following flags are documented for that mode as of 30 October 2026:[19][20][21][45]

| Flag | Documented behavior |
| --- | --- |
| `--max-budget-usd` | Stops the run once estimated API spend reaches the amount (print mode only). The check uses a client-side estimate that can differ from the bill, subagent spend counts, and spend can pass the cap |
| `--max-turns` | Limits agentic turns (print mode only) and exits with an error when the limit is reached; no limit by default |
| `--permission-mode` | Starts in a mode such as `acceptEdits`, `auto`, `dontAsk` or `bypassPermissions`; Anthropic lists `dontAsk` for "locked-down CI and scripts" and `bypassPermissions` for "isolated containers and VMs only" |
| `--allowedTools` | Tools that run without a prompt, using rule syntax such as `"Bash(npm test)"`; MCP tools are written `mcp__<server>__<tool>` or `mcp__<server>__*` |
| `--output-format json` | Returns a payload that includes `total_cost_usd`, again a client-side estimate |
| `--bare` | Skips auto-discovery of hooks, skills, plugins, MCP servers, auto memory and CLAUDE.md; Anthropic recommends it for scripted calls. MCP servers then connect only when passed with `--mcp-config` |
| `--permission-prompts none` | For unattended runs, denies anything that would wait for a person and tells Claude not to retry it (Claude Code v2.1.259 or later) |

In Claude Code v2.1.302 or later, a `claude -p` run with no permission mode set starts in Manual (`default`) mode, and calls that need approval are denied unless an allow rule, hook or other mechanism approves them.[21] Claude Code exits with code 0 on success and a non-zero code on failure, and with code 143 when stopped by SIGTERM.[20] Anthropic's own CI example is `claude -p "run the test suite" --permission-mode dontAsk --allowedTools "Bash(npm test)" "Read"`.[21] An illustrative nightly playtest call built from the documented flags, with a placeholder npm script and example limits:

```bash
claude -p "Follow tests/PLAYTEST.md and write the report it describes. Do not edit game code." --permission-mode dontAsk --allowedTools "Read" "Edit(reports/**)" "Bash(npm run playtest *)" --max-turns 30 --max-budget-usd 3.00 --output-format json
```

Anthropic notes that file path rules are checked against `Edit(path)` and `Read(path)` only, so a `Write(path)` rule never matches; `Edit(reports/**)` covers writing reports.[45] If the playtest needs an engine bridge, the bridge's tools must be allowed by name, and a `--bare` run must receive the server through `--mcp-config`.[20][21] Without `--bare`, Anthropic notes that a `-p` session runs the hooks in a project's `.claude/settings.json` and connects the servers in its `.mcp.json` without a trust dialog, so run it only in a repository whose configuration has been reviewed.[20] The hub's unattended-run plan covers branch-per-task isolation and merge gates; the Just Farm developer described "a hard time and money budget per card".[18]

### Builds and tests in GitHub Actions

GameCI publishes GitHub Actions for Unity: `game-ci/unity-test-runner` runs tests and `game-ci/unity-builder` produces builds. Its quick start, adapted below with its comment lines and job name removed, the workflow renamed and a job-level `timeout-minutes` added, tests and builds a WebGL project on every push and pull request.[23][26]

```yaml
name: Unity CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          lfs: true
      - uses: actions/cache@v3
        with:
          path: Library
          key: Library-${{ hashFiles('Assets/**', 'Packages/**', 'ProjectSettings/**') }}
          restore-keys: |
            Library-
      - name: Run tests
        uses: game-ci/unity-test-runner@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
        with:
          githubToken: ${{ secrets.GITHUB_TOKEN }}
      - name: Build project
        uses: game-ci/unity-builder@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
        with:
          targetPlatform: WebGL
      - uses: actions/upload-artifact@v4
        with:
          name: Build
          path: build
```

Points from GameCI's documentation that matter when an agent sets this up:[23][24][25]

- All Unity actions require activation. A Personal license needs a one-time manual step that produces a `.ulf` file in Unity Hub; its contents go in the `UNITY_LICENSE` secret, with the account credentials in `UNITY_EMAIL` and `UNITY_PASSWORD`. Professional licenses add a `UNITY_SERIAL` secret in place of the license file.
- The test runner runs Play Mode and Edit Mode tests by default. `testMode` accepts `All`, `PlayMode`, `EditMode` and `Standalone`, and `All` does not include `Standalone`.
- Results go to an `artifacts` folder by default. Upload them with `if: always()` so failing runs keep their reports; a `githubToken` adds a check run with the results, provided the repository's workflow permissions are set to read and write (the default is read-only). The sample above uploads only the build; add an `actions/upload-artifact` step for `artifacts` with `if: always()` to keep the test reports.
- GitHub cancels a job at its `timeout-minutes` value, which defaults to 360 minutes.[26]

Godot documents command-line export as "especially useful for continuous integration setups", and says `--headless` is required on platforms without GPU access, such as CI.[27] The documented form is `godot --headless --export-release "Linux/X11" /var/builds/project`. The `godot` binary must be the editor, not an export template; export templates must be installed; the preset name must match `export_presets.cfg`; and the target directory must exist.[27] The [Godot guide](https://aiwiki.ai/wiki/developing_godot_games_with_ai) and [Unity guide](https://aiwiki.ai/wiki/developing_unity_games_with_ai) cover the engines' own test commands.

For agent tasks inside GitHub, Anthropic's Claude Code GitHub Action (`anthropics/claude-code-action@v1`) passes CLI flags through `claude_args`. Anthropic's cost advice for it is to set `--max-turns` there, set workflow-level timeouts and use GitHub's concurrency controls; API keys belong in GitHub Secrets, not in the repository.[22] GameCI also documents deployment to Steam, and recommends a dedicated Steam build account that only has the Edit App Metadata and Publish App Changes To Steam permissions.[42]

## Test the platforms and controls you promise

Create a small matrix that matches the release claims. Cover the actual operating systems, browser families, screen sizes and input devices the project intends to support. Keep unknown combinations visible rather than counting them as passes.

| Situation | Check when relevant |
| --- | --- |
| First launch | Starts without development tools; controls and objective can be found |
| Keyboard, controller or touch | Every required action and menu can be operated |
| Window resize or orientation change | UI remains readable and input coordinates stay aligned |
| Pause, focus loss and return | Held input clears or resumes according to the chosen rule |
| Save, quit and reload | Supported progress and settings survive as intended |
| A second play session | No stale score, duplicated events or unintended retained state |
| Slow or absent network | Online features fail according to the stated design |
| Hosted browser build | Assets, audio and interaction work inside the actual embedded page |

Playwright's device emulation configures properties such as viewport and touch support. It helps exercise web layouts and input paths, but does not replace checking the intended physical devices.[8]

For an itch.io browser release, test the uploaded page, not only a local preview. itch.io embeds HTML games in an iframe; a multi-file ZIP needs an `index.html` entry point and the required assets, with case-sensitive filenames.[9] The ZIP should contain no more than 1,000 files after extraction, with paths of at most 240 characters, at most 500 MB of extracted content and no single file over 200 MB.[9] Launch and fullscreen settings can change the way players encounter the game. Confirm that the controls and layout work in that setting.

## Include accessibility in the play loop

Test whether players can read objectives, identify interactive elements and operate the menus as well as the game. Microsoft's Xbox Accessibility Guidelines discuss configurable text presentation and alternative input options.[10][11] They provide useful design guidance; citing them does not establish compliance with every platform or accessibility requirement. Microsoft's overview of the guidelines (version 3.2, published 8 June 2023) says they are meant, among other uses, "for test teams as a checklist to validate the accessibility of their titles", but are not intended "to act as a checklist to validate any type of compliance or legal requirements".[29]

The Game Accessibility Guidelines, a reference produced by studios, specialists and academics, sort recommendations into Basic, Intermediate and Advanced levels.[28] Several Basic items convert directly into test cases:

| Guideline (Basic level) | Test case |
| --- | --- |
| Allow controls to be remapped / reconfigured | Remap every required action, restart the game and confirm the mapping persists |
| Ensure that all areas of the user interface can be accessed using the same input method as the gameplay | Complete the menus with the controller or touch input used in play |
| Ensure no essential information is conveyed by a fixed colour alone | Review key states with color removed from the capture |
| Provide subtitles for all important speech | Trigger each spoken line with subtitles on |
| Use an easily readable default font size | Check text at the smallest supported display |

Check the smallest intended display and the actual viewing conditions. Review clipped labels, text over busy backgrounds, remapped controls, settings that survive a restart, and information carried only by color or sound. Where the design supports subtitles or alternative feedback, exercise those features instead of merely confirming that a settings toggle exists.

Ask playtesters to try the build without coaching them through the controls. Record where they hesitate, what they expected and what the game did. Separate an observed event, such as repeatedly missing a restart control, from a proposed solution, such as changing its position. Let the assistant suggest alternatives after the problem is documented.

## Profile a representative run

Choose the target device, scene and performance goal before asking for optimization. A crowded gameplay area, a long session or a scene transition can be more useful than an empty room. Retain comparable measurements before and after the change.

Godot's profiler reports frame and physics timings and helps inspect individual spikes and script work; its built-in script profiler does not support C#.[12] Use the appropriate engine or browser profiler for the project. Check whether the measured bottleneck concerns scripts, physics, rendering, asset loading or another service before rewriting code.

Frame time makes a target concrete: 60 frames per second permits about 16.7 milliseconds per frame, while 30 permits about 33.3 milliseconds. These are arithmetic budgets, not a promise that every frame will meet them or a recommendation that every game must target either rate. Record spikes and loading behavior as well as an average. Retest correctness and visual output after an optimization.

## Check runtime AI as a separate service

If the released game calls a model during play, test the dependency deliberately. If AI only helped write the project or prepare retained assets, those development tools need not be active for the player.

For runtime features, exercise a timeout, unavailable service, rejected or malformed response, and exhausted usage allowance. Define which fallback appears and whether the player can continue. Check that a failed or repeated request cannot award an item twice or corrupt a save. Keep authoritative game state and validation in the application's own systems unless a different design has been explicitly chosen.

Record actual request volumes, response times and relevant token or asset usage. Include retries when estimating operating cost. Keep private provider keys out of a downloadable game or browser bundle; Vite explicitly warns that variables exposed to client code, including `VITE_` values, must not contain secrets.[13] These are engineering checks to adapt to the service, not a claim that a prompt can enforce all game rules.

Store rules add their own requirements for content generated during play:

- **Steam** asks, for Live-Generated content, what guardrails prevent illegal output. Its FAQ says a game that calls a paid live AI service must manage access to that service for players and collect any payment through a Steam-supported method, such as the base price, microtransactions, a subscription or DLC.[15]
- **Google Play** requires apps that generate content using AI to "contain in-app user reporting or flagging features that allow users to report or flag offensive content to developers without needing to exit the app".[35]
- **Apple's** App Store Review Guidelines (last updated 16 October 2026) list "AI content creation apps" among user-generated content apps, which must include filtering, a reporting mechanism with timely responses, user blocking and published contact information. Guideline 5.1.2(i) requires apps to disclose where personal data will be shared with third parties, "including with third-party AI", and to obtain explicit permission first.[36]

Turn each applicable rule into a test case: trigger the report flow from inside the game, confirm that the filter or guardrail engages on an unacceptable request, and confirm the consent prompt appears before any personal data is sent.

## Prepare accurate release materials

Compare the store description, screenshots and supported-feature list with the candidate build. Valve reviews both the store presence and product build before a Steam release; its review guidance requires startup on the advertised supported operating systems and implementation of listed features.[14] A successful test run alone does not replace that process.

### Steam timeline

| Step | What Valve's documentation says |
| --- | --- |
| Coming Soon page | New products must have a Coming Soon page up for at least two weeks before release. The page itself is reviewed first; Valve asks for the review request at least 7 business days before the page should go live[30] |
| Store presence review | Typically 3-5 business days. The page should only contain features and content available at launch, and screenshots "must only contain gameplay", not concept art or pre-rendered cinematic stills[14] |
| Build review | Typically 3-5 business days; plan for at least 7. Submit a near-final build; the store presence must be submitted before the build[14][31] |
| Release | Approved titles do not release themselves: the developer presses "Release App" after the page has been Coming Soon for at least two weeks and the build is reviewed[31] |
| Playtest (optional) | A separate "child" appID with signups on the main store page or distributed keys. Its store review checklist consists only of capsule images and icons, and it can be set to "Not Playable" when testing ends[32] |

Steam Playtest is a way to put the reviewed build in front of external players without the main game's reviews or wishlists. Valve notes that keys already granted are not automatically revoked when a playtest is later marked Not Playable.[32]

### Disclosure forms

Check the platform's current disclosure form against the content actually shipped. As checked on 30 October 2026:

| Platform | Relevant documented distinction |
| --- | --- |
| Steam | Its Content Survey focuses on generated content shipped with the game and consumed by players, distinguishes pre-generated from live-generated content, and asks for safeguards for live generation.[15] |
| itch.io | Its quality guidelines ask projects containing generative material to use AI Disclosure accurately; the statement about strict enforcement specifically addresses game asset pages.[16] |
| Google Play | Apps that generate content with AI must offer in-app reporting or flagging of offensive content.[35] |
| Apple App Store | AI content creation apps are treated as user-generated content apps; sharing personal data with third-party AI needs disclosure and explicit permission.[36] |
| Fab (Epic) | Licensors must tag content "CreatedWithAI" when a material portion was generated with generative AI programs.[37] |

Steam's current wording says that "Efficiency gains through the use of these tools is not the focus of this section"; the section concerns "content that ships with your game, and is consumed by players", such as artwork, sound, narrative and localization.[15] GameSpot reported the rewrite on 19 January 2026.[33] Once the build and store page are approved, some survey answers cannot be edited without contacting Steam Support, so re-check the survey when an update adds generated content.[15] Just Farm's store disclosure is a worked example of the pre-generated case: "Generative AI tools were used during development to assist in the production of pre-generated visual and audio content. All content was reviewed and integrated by the developer before inclusion in the game. No generative AI is used during gameplay."[44] [Steam AI disclosure](https://aiwiki.ai/wiki/steam_ai_disclosure) provides more background.

itch.io added its "Generative AI disclosure" field on 20 November 2024. It asks whether a project contains generative AI results and, if so, which kinds: Graphics, Sound, Text & Dialog, and Code. A "yes" adds the AI Generated tag, and the field was made required for asset creators.[34] The quality guidelines state that traditional game AI such as NPC pathfinding, enemy behavior, procedural level generation and dynamic difficulty "are not considered generative AI and don't need tagging".[16]

Purchased assets are part of what ships. Fab's license requires sellers to tag content "CreatedWithAI" when a material portion of it was produced with generative AI programs; features that only operate on existing content, such as content-aware fill or AI upscaling, do not count.[37] Record such tags in the project's asset list, because a store disclosure covers the content in the build, whoever produced it. Epic's chief executive Tim Sweeney has argued that an AI tag "makes no sense for game stores", while defending disclosure on Fab because its business customers "cannot buy assets without this info".[38][39] See [AI game development](https://aiwiki.ai/wiki/ai_game_development) for the wider platform debate.

Keep coding assistance, retained generated assets and runtime generation separate when describing the workflow. Do not infer a blanket disclosure exemption or permission to distribute content from a short summary. Steam states that completing its survey does not override its content rules.[15]

## Expect varied community reception

Community rules differ from store rules. r/gamedev's moderators wrote in August 2026 that the subreddit "does not prohibit the use of AI" and that "AI is a valid game development topic", and that moderation targets low-quality contributions rather than tool use.[40] A September 2026 follow-up said posts amounting to little more than "I hate AI", "I love AI", "Can I use AI?" or "Is AI ethical?" would be removed, with temporary bans for a first offence.[41]

Other communities apply other rules. The Just Farm developer wrote that "a couple of gamedev subs removed my posts as I disclosed AI use", and shared the workflow on r/accelerate instead.[18] Willison wrote that he would not enter his vibe-coded games in traditional game jams or competitions.[43] Read each venue's current rules before posting, show the gameplay, describe the workflow concretely and say what feedback is wanted.

## Common problems and fixes

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

| Symptom | Likely cause | Fix |
| --- | --- | --- |
| Tests pass but the game is unplayable | Tests cover isolated rules, not the complete loop | Add an exported-build case that plays start to win, loss and restart; keep human playtests (general advice) |
| Works in the editor, fails in the build | Editor caches, missing export templates, excluded resources or credentials that stay on the developer's machine | Export early, test the exported artifact, and check export settings; Godot keeps confidential export options in an uncommitted credentials file[3][27] |
| Godot CI export fails or writes nowhere | Wrong binary, no templates, preset name mismatch or missing target directory | Use the editor binary with `--headless`, install templates, match `export_presets.cfg` and create the directory first[27] |
| Unity CI job fails before any test runs | License activation not configured | Create the `.ulf` file or serial and store it with the account credentials as secrets[25] |
| An unattended agent run never finishes or overspends | No turn, budget or wall-clock limit | Set `--max-turns`, `--max-budget-usd` and a job `timeout-minutes`; leave headroom because spend can pass the cap[19][26] |
| A headless agent run silently does nothing useful | Required tool calls were denied in a non-interactive run | Allow the exact tools, including MCP tools by name, or choose a permission mode deliberately; with `--output-format stream-json` the final result lists them in `permission_denials`[20][21] |
| An agent playtest reports success without evidence | The prompt asked for a verdict, not a report | Require screenshots, log lines and a pass/fail/blocked status per case (general advice) |
| Screenshot tests fail on another machine | Rendering differs by OS, browser, hardware and headless mode | Generate baselines and compare in the same environment[7] |
| Replays desynchronize across browsers | Platform differences in floating-point math functions | Compare a fixed replay on each browser; Willison's project replaced `Math.sin()` and `Math.cos()`[17] |
| Disclosure omits shipped AI content | Generated or purchased assets were not tracked | Keep an asset list with provenance, including Fab "CreatedWithAI" tags, and check it against the survey before each update[15][37] |
| Runtime model outage breaks the game | No fallback or timeout | Test timeouts, errors and exhausted allowances with a defined fallback (general advice) |
| Store review rejects screenshots or features | Screenshots show concept art or planned features | Use gameplay captures from the reviewed build and list only features available at launch[14] |
| An itch.io browser build shows a blank page or missing assets | Missing `index.html`, wrong filename case or root-absolute (`/...`) asset paths | Put `index.html` at the entry point, match filename case, use relative paths and stay within the documented ZIP limits[9] |

## After release

Release with a retained artifact, a short known-issues list and a way to report a reproducible problem. Confirm that an update can be compared with the prior version, and check save compatibility when changing stored data. After a reported defect, reproduce it against the identified build, fix the smallest relevant cause and rerun the affected checks before publishing another candidate. Steam allows updates at any time after the first approval without another review, so the release checks above are the main gate on later builds.[14]

## See also

- [Developing Games with AI](https://aiwiki.ai/wiki/developing_games_with_ai) (hub)
- [Developing Browser Games with AI](https://aiwiki.ai/wiki/developing_browser_games_with_ai)
- [Developing Godot Games with AI](https://aiwiki.ai/wiki/developing_godot_games_with_ai)
- [Developing Unity Games with AI](https://aiwiki.ai/wiki/developing_unity_games_with_ai)
- [Developing Unreal Engine Games with AI](https://aiwiki.ai/wiki/developing_unreal_engine_games_with_ai)
- [Creating Game Assets with AI](https://aiwiki.ai/wiki/creating_game_assets_with_ai)
- [Steam AI disclosure](https://aiwiki.ai/wiki/steam_ai_disclosure)
- [AI game development](https://aiwiki.ai/wiki/ai_game_development)
- [Claude Code](https://aiwiki.ai/wiki/claude_code)

## References

1. Xiaoyu Chen et al. [SWE-Game: Can Coding Agents Build the Games We Want?](https://arxiv.org/abs/2609.33678v3). arXiv preprint, version 3, 7 October 2026.
2. Tongxu Luo et al. [GameCraft-Bench: Can Agents Build Playable Games End-to-End in a Real Game Engine?](https://arxiv.org/abs/2606.17861). arXiv preprint, 16 June 2026.
3. Godot Engine. [Exporting projects](https://docs.godotengine.org/en/stable/tutorials/export/exporting_projects.html). Stable documentation. Accessed 30 October 2026.
4. Unity. [Edit Mode vs. Play Mode tests](https://docs.unity3d.com/Packages/com.unity.test-framework@1.4/manual/edit-mode-vs-play-mode-tests.html). Unity Test Framework 1.4 documentation. Accessed 30 October 2026.
5. Epic Games. [Automation Test Framework](https://dev.epicgames.com/documentation/en-us/unreal-engine/automation-test-framework-in-unreal-engine). Unreal Engine documentation. Accessed 30 October 2026.
6. Unity. [Run, test & build: unity-cli command reference](https://github.com/Unity-Technologies/skills/blob/main/skills/unity-cli/references/build-run-test.md). Official Unity CLI skill reference. Accessed 30 October 2026.
7. Microsoft. [Visual comparisons](https://playwright.dev/docs/test-snapshots). Playwright documentation. Accessed 30 October 2026.
8. Microsoft. [Emulation](https://playwright.dev/docs/emulation). Playwright documentation. Accessed 30 October 2026.
9. itch.io. [Uploading HTML5 games](https://itch.io/docs/creators/html5). Creator documentation. Accessed 30 October 2026.
10. Microsoft. [Xbox Accessibility Guideline 101: Text display](https://learn.microsoft.com/en-us/xbox/accessibility/xbox-accessibility-guidelines/101). Accessed 30 October 2026.
11. Microsoft. [Xbox Accessibility Guideline 107: Input](https://learn.microsoft.com/en-us/xbox/accessibility/xbox-accessibility-guidelines/107). Accessed 30 October 2026.
12. Godot Engine. [The Profiler](https://docs.godotengine.org/en/stable/tutorials/scripting/debug/the_profiler.html). Stable documentation. Accessed 30 October 2026.
13. Vite. [Env Variables and Modes](https://vite.dev/guide/env-and-mode). Official documentation. Accessed 30 October 2026.
14. Valve. [Review Process](https://partner.steamgames.com/doc/store/review_process). Steamworks documentation. Accessed 30 October 2026.
15. Valve. [Content Survey](https://partner.steamgames.com/doc/gettingstarted/contentsurvey). Steamworks documentation. Accessed 30 October 2026.
16. itch.io. [Content creator quality guidelines](https://itch.io/docs/creators/quality-guidelines#ai-disclosure). Accessed 30 October 2026.
17. Simon Willison. [Battle Drones: a vibe coded RTS with audio-based multiplayer](https://simonwillison.net/2026/Oct/20/battledrones/). Simon Willison's Weblog, 20 October 2026.
18. u/SirKnighty. [My game got removed from gamedev subs for using AI, so here's exactly how I made it](https://www.reddit.com/r/accelerate/comments/1xh786k/my_game_got_removed_from_gamedev_subs_for_using/). r/accelerate, Reddit, 27 October 2026. Developer's first-person account.
19. Anthropic. [CLI reference](https://code.claude.com/docs/en/cli-reference). Claude Code documentation. Accessed 30 October 2026.
20. Anthropic. [Run Claude Code programmatically](https://code.claude.com/docs/en/headless). Claude Code documentation. Accessed 30 October 2026.
21. Anthropic. [Choose a permission mode](https://code.claude.com/docs/en/permission-modes). Claude Code documentation. Accessed 30 October 2026.
22. Anthropic. [Claude Code GitHub Actions](https://code.claude.com/docs/en/github-actions). Claude Code documentation. Accessed 30 October 2026.
23. GameCI. [Getting started (GitHub)](https://game.ci/docs/github/getting-started). GameCI documentation, v4. Accessed 30 October 2026.
24. GameCI. [Test runner](https://game.ci/docs/github/test-runner). GameCI documentation, v4. Accessed 30 October 2026.
25. GameCI. [Activation](https://game.ci/docs/github/activation). GameCI documentation, v4. Accessed 30 October 2026.
26. GitHub. [Workflow syntax for GitHub Actions](https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax). GitHub Docs. Accessed 30 October 2026.
27. Godot Engine. [Command line tutorial](https://docs.godotengine.org/en/stable/tutorials/editor/command_line_tutorial.html). Stable documentation. Accessed 30 October 2026.
28. Game Accessibility Guidelines. [Full list](https://gameaccessibilityguidelines.com/full-list/). Accessed 30 October 2026.
29. Microsoft. [Xbox Accessibility Guidelines V3.2](https://learn.microsoft.com/en-us/gaming/accessibility/guidelines). Microsoft Game Dev documentation. Accessed 30 October 2026.
30. Valve. [Coming Soon](https://partner.steamgames.com/doc/store/coming_soon). Steamworks documentation. Accessed 30 October 2026.
31. Valve. [Release Process](https://partner.steamgames.com/doc/store/releasing). Steamworks documentation. Accessed 30 October 2026.
32. Valve. [Steam Playtest](https://partner.steamgames.com/doc/features/playtest). Steamworks documentation. Accessed 30 October 2026.
33. Alessandro Barbosa. [Valve Updates AI Disclosure Guidelines To Allow For AI-Powered Tools](https://www.gamespot.com/articles/valve-updates-ai-disclosure-guidelines-to-allow-for-ai-powered-tools/1100-6537483/). GameSpot, 19 January 2026.
34. leafo. [Generative AI disclosure tagging](https://itch.io/t/4309690/generative-ai-disclosure-tagging). itch.io Developer Updates, 20 November 2024.
35. Google. [AI-Generated Content](https://support.google.com/googleplay/android-developer/answer/13985936). Play Console Help, Google Play policy. Accessed 30 October 2026.
36. Apple. [App Store Review Guidelines](https://developer.apple.com/app-store/review/guidelines/). Last updated 16 October 2026. Accessed 30 October 2026.
37. Epic Games. [Fab End User License Agreement](https://www.fab.com/eula). Last updated 1 October 2024; section on content created with generative AI programs. Accessed 30 October 2026.
38. Tim Sweeney (@TimSweeneyEpic). [Post on AI tags](https://x.com/TimSweeneyEpic/status/1993687499621728312). X, 26 November 2025.
39. Tim Sweeney (@TimSweeneyEpic). [Post on Fab disclosures](https://x.com/TimSweeneyEpic/status/2114163368903008392). X, 25 October 2026.
40. r/gamedev moderators. [r/gamedev Policy on AI Use](https://www.reddit.com/r/gamedev/comments/1vrnqyt/rgamedev_policy_on_ai_use/). Reddit, 18 August 2026.
41. r/gamedev moderators. [/r/gamedev Policy on Removing Posts about AI](https://www.reddit.com/r/gamedev/comments/1wb1n69/rgamedev_policy_on_removing_posts_about_ai/). Reddit, 8 September 2026.
42. GameCI. [Deploy to Steam](https://game.ci/docs/github/deployment/steam). GameCI documentation, v4. Accessed 30 October 2026.
43. Simon Willison. [The October inflection point for vibe game development](https://simonwillison.net/2026/Oct/28/vibe-game-development/). Simon Willison's Weblog, 28 October 2026.
44. Dasi Games. [Just Farm](https://store.steampowered.com/app/5341880). Steam store page, AI Generated Content Disclosure section. Accessed 30 October 2026.
45. Anthropic. [Configure permissions](https://code.claude.com/docs/en/permissions). Claude Code documentation. Accessed 30 October 2026.