Build Your First Playable Unreal Level with Claude Opus 5.5

The practical answer is to avoid connecting every tool on day one. First prove that Claude Code can read the Unreal Editor instance that is actually running. Then build a greybox level that you can walk through, collect three objects in, finish, and restart. Validate every stage yourself in Play. Only after that loop is stable should you decide whether a generated 3D asset or a Blender cleanup pass is worth the extra moving parts.

This is a documentation-based workflow, not a claim that the author ran your project. Epic still labels Unreal MCP Experimental and says features, APIs, and data formats can change. That is why this guide treats an MCP connection, a successful tool result, and a playable result as three different kinds of evidence.

Decide whether this workflow fits you

This approach works best for a solo creator who already understands basic Unreal concepts, can keep a project under source control, and is willing to Play-test after each small change. Claude can accelerate work you can describe and inspect; it cannot decide whether movement, camera behavior, collision, or game feel is acceptable.

Situation	Recommendation
You can read the project structure, review changes, and test in Play	Start with the minimal greybox below
You only need to validate a game loop	Keep Unreal primitives; skip Meshy and Blender for now
The project has no backup or rollback path	Stop and create a copy plus version-control checkpoints
You expect one prompt to produce a finished game	Break the goal into observable systems first
The change is one actor transform or one numeric value	Editing it manually is usually faster

Anthropic positions Opus 5.5 for complex coding and long-running agentic work. That does not make a visual game result self-verifying. Let the model inspect, plan, and execute; keep approval, observation, and Play validation with the human.

Define the smallest playable result before installing more tools

The target for this guide has only four requirements:

1. The player starts at Player Start and can follow a clear route to an endpoint.
2. Three visible collectibles each increment a counter once, from 0 to 3.
3. Reaching the endpoint produces a win only after all three have been collected.
4. Pressing R restores player position, counter, collectibles, and win state.

Put those requirements in the project brief. For every batch, record the change, expected result, actual result, and pass/fail decision. Connected is not playable. Compiled is not playable. A tool accepting a request is not playable. Only a hands-on Play pass proves the corresponding gate.

Gate 1: connect Claude Code to the official Unreal MCP

Create a recovery point first

Save the project and commit or shelve the current state. Epic’s official plugin gives Claude broad live access to the running editor, including a tool that can execute Python inside the editor process. Its README says to treat this like running arbitrary assistant-generated code, save before long sessions, and review the resulting diff.

Do not use --dangerously-skip-permissions on an important project. Learn the workflow in a copy, sandbox, or disposable branch.

Enable both Unreal plugins

This guide follows Epic’s current Unreal MCP page, which is published under Unreal Engine 5.8 Documentation. It assumes that your engine build actually includes Unreal MCP (ModelContextProtocol) and All Toolsets (AllToolsets). Do not infer that every UE5 release contains the same plugins. If either entry is absent, stop and use a build covered by Epic’s documentation instead of substituting a community MCP.

Follow the official setup:

• In Edit → Plugins, enable Unreal MCP.
• Enable All Toolsets as well. The server can be present but expose no usable tools without it.
• Restart the editor.
• Enable Auto Start Server in Editor Preferences, or run this in the editor console:

ModelContextProtocol.StartServer

The default local endpoint is http://127.0.0.1:8000/mcp. It has no authentication by default and is not intended for remote exposure. Do not forward it to the public internet or use it on a shared machine.

Generate the Claude Code configuration

Run this in the Unreal console:

ModelContextProtocol.GenerateClientConfig ClaudeCode

A launcher build normally writes .mcp.json beside the .uproject; a source build can place it at the workspace root beside Engine/. Regenerate it after changing the port. Start Claude Code from the root that contains the generated configuration.

Install Epic’s official Claude Code plugin:

/plugin install unreal-engine-skills-for-claude-code@claude-plugins-official

If the official marketplace is missing, add it first:

/plugin marketplace add anthropics/claude-plugins-official

Keep model access separate from editor and asset services

Claude Code can use an Anthropic account or a compatible model API. When using BetterToken, its current Claude Code setup guide says to set ANTHROPIC_BASE_URL to https://bettertoken.ai without /v1, and to provide ANTHROPIC_AUTH_TOKEN locally. Never paste a real API key into a chat, commit it to the repository, or include it in a material bundle.

Anthropic’s official model ID is claude-opus-5-5. When routing through BetterToken, copy the exact ID from the current Model Plaza and confirm that it is available to the selected key group; after launch, use /model and the provider’s request records to verify actual routing instead of trusting an old copied configuration.

Verify a live read, not just a green indicator

Check all four layers:

• /plugin lists the official Unreal plugin as enabled.
• /mcp lists unreal-mcp.
• Unreal’s Output Log has no bind or dependency error.
• A read-only prompt returns the real active level name, major actors, and whether Player Start exists.

That last check proves the editor is reachable. Epic notes that a connected proxy or cached tools do not prove live Unreal calls can succeed.

Gate 2: build only a walkable greybox

Start from an already playable third-person baseline. A Player Start marks a spawn location; it does not by itself supply a controllable character, GameMode, input, or camera. For a new project, use Unreal’s Third Person template. In an existing project, verify that the active GameMode spawns a controllable third-person pawn, movement input and the follow camera work, and the level contains a Player Start.

Before MCP changes any geometry, click Play, not Simulate. Confirm that a character actually spawns, WASD moves it, and the mouse controls the camera; then stop PIE. If any check fails, repair this baseline first instead of hiding the problem inside the greybox prompt.

After the baseline passes, ask Claude to read the current level, GameMode, player character, and available toolsets, then list its plan and every asset it will modify. Missing tools should stop the task rather than trigger a silent substitute. A useful boundary is:

Using the third-person baseline that has already passed Play, build a minimal greybox in the current level. Preserve the existing player character, GameMode, input mappings, and camera; do not replace or rebuild them. Use primitives for the floor, boundaries, one clear route, and an endpoint marker. Add no enemies, art assets, or complex UI. Report every asset created or changed. Stop if a required tool is missing, compilation fails, or a result is not an explicit success.

Keep three execution rules:

• Serialize dependent mutations to the same asset or editor state.
• Wait for C++, Blueprint, or shader compilation to finish; an accepted request is not a finished compile.
• Read every result status and stop on anything other than explicit success.

Play gate A: Click Play again, start with the character spawned at Player Start, and walk the whole route. The player must not escape the boundary, snag on a narrow gap, or need to jump over an invisible obstruction. Fix only the observed failure; do not casually redesign the camera, materials, or route.

Save, commit, and mark a recovery point after it passes.

Gate 3: add three collectibles

The next batch adds only collection rules and protects the route you already accepted:

Add three clearly visible and separated collectibles along the route. Touching one must trigger once, then hide or remove it, while a readable counter moves from 0 to 3. Do not move Player Start, the route, boundaries, or endpoint. Report the Blueprints, variables, events, and UI assets involved, then provide a Play checklist.

Play gate B: collect them in normal order and reverse order; each increments once; the sequence is 1, 2, 3; revisiting an old location does not increment again; starting a new Play session begins at 0.

If Claude reports completion but the counter does not change in Play, the gate failed. Record what happened and the Output Log, then ask for diagnosis before one narrow fix.

Gate 4: add win and restart behavior

The final gameplay batch adds only completion and reset logic:

Reaching the endpoint should show a win only when the counter is 3. With fewer collectibles, the endpoint must not win. Pressing R must restart the level and restore player position, all three collectibles, the counter, and win UI. Preserve the existing route and input. Report the changes and provide a five-step Play checklist.

Play gate C:

1. Reach the endpoint with two items: no win.
2. Collect all three and reach it: win appears.
3. Press R halfway through: every state resets.
4. Press R after winning: every state resets.
5. Collect in a different order: behavior remains correct.

Only now do you have a first playable level. Save, commit, and keep a stable greybox version that does not depend on external art.

Add Meshy or Blender only after the greybox passes

These are optional branches, not default prerequisites.

Use Meshy only when a distinctive prop is worth it

This remains an optional branch. The official Meshy MCP server requires a valid MESHY_API_KEY; API keys require an eligible paid plan, and API requests use prepaid API credits. A web-app plan or workspace allowance is not proof that API access or balance is usable. Before generation, check with meshy_check_balance.

For Claude Code on Bash, use the following local setup. Enter the key silently and never paste it into chat or commit the resulting local configuration:

read -rs MESHY_API_KEY && export MESHY_API_KEY
claude mcp add-json meshy "{\"command\":\"npx\",\"args\":[\"-y\",\"@meshy-ai/meshy-mcp-server\"],\"env\":{\"MESHY_API_KEY\":\"${MESHY_API_KEY}\"}}"
unset MESHY_API_KEY

Then use /mcp to confirm that meshy is connected, ask Claude to list the available Meshy tools, and call meshy_check_balance. These connection and balance checks do not create a generation task. Stop here if the key, plan eligibility, or API balance is not usable.

Use one simple text-to-3D collectible route:

1. Call meshy_text_to_3d with a short, specific prop prompt and target_formats: ["glb"]. This creates an untextured preview. Call meshy_text_to_3d_refine only after the preview succeeds and only when texture is worth a separate task. Refine returns a new task ID: keep both the preview and refine IDs, then use the refine ID with task type text-to-3d for status checks and download of the textured result.
2. Record the returned task ID and the task type text-to-3d. Do not preserve only a natural-language chat response.
3. Call meshy_get_task_status with the same ID and type. PENDING, IN_PROGRESS, or a tool-level TIMEOUT is not failure. A network interruption, 429, or 5xx during a status check also does not make the task FAILED; query the same task ID later instead of creating a duplicate paid task.
4. Download only after SUCCEEDED. Read task_error after FAILED, and stop after CANCELED. Save the result to an explicit local source-asset path, for example:

meshy_download_model
task_id: <same task ID>
task_type: "text-to-3d"
format: "glb"
save_to: "<absolute-project-path>/SourceAssets/Props/CollectibleMarker/marker.glb"

Verify that the file exists before moving to Blender or Unreal import. Under Meshy’s Asset Retention, API assets for non-Enterprise customers are retained for at most three days, so do not keep only a download URL.

Asset gate D, only when Meshy is selected: The local GLB opens repeatedly, and the task ID, task type, prompt, final status, and local path are recorded. This still does not prove that the asset is ready for Unreal.

Use Blender only when cleanup has a clear job

Manual cleanup is enough; readers do not need another MCP by default. Only when you deliberately choose Claude-driven Blender should you install the official add-on, LLM client, and MCP server from the Blender MCP page, then begin with a read-only inventory of scene objects before allowing edits. Do not mix in ports, tool names, or setup steps from the community ahujasid/blender-mcp project. Blender also warns that its official MCP executes LLM-generated code without data-protection guards, so use a VM or a system without sensitive data.

For one static collectible, use this minimal route:

1. In Blender, choose File → Import → glTF 2.0 (.glb/.gltf) and open marker.glb. Keep only the intended prop, remove stray geometry manually, and inspect scale, orientation, origin, names, and materials.
2. Save the cleaned source as <absolute-project-path>/SourceAssets/Props/CollectibleMarker/marker-clean.blend so the editable source remains recoverable.
3. Select only the cleaned static prop, choose File → Export → glTF 2.0, set the format to glTF Binary (.glb), enable Selected Objects and Apply Modifiers, and save marker-clean.glb beside the .blend file.
4. In Unreal’s Content Browser, create or open /Game/Assets/Props/Collectibles/ and import marker-clean.glb. In the Interchange import preview, confirm that the intended entry is a Static Mesh, import only that static prop, and save the asset. Inspect its size in the Static Mesh Editor; add simple collision only when needed, and do not let visible-mesh collision replace or break the existing overlap trigger.
5. Open the collectible Blueprint or Actor that already passed Play and replace only the visible Static Mesh component’s mesh reference. Preserve its trigger volume, one-shot collection event, counter, win and restart logic, and placed instances. Compile, save, and Play again.

Asset gate E, only when the Blender/import branch is selected: The .blend, cleaned .glb, and Unreal Static Mesh all open; scale, orientation, origin, and collision are explainable; the visible mesh changed without changing gameplay logic; Play gates A–C still pass.

Troubleshoot by evidence layer

Symptom	Check first	Do not mistake it for
/mcp says connected but the level cannot be read	Running editor, Output Log, a real read-only call	A working game connection
Server starts but no tools appear	AllToolsets, then ModelContextProtocol.RefreshTools if needed	A model capability failure
Calls hang or error	Compilation, level loading, or active PIE	Automatically a network issue
Blueprint tools return but gameplay fails	Result status, compile output, Output Log, manual Play	Completion
Meshy status check times out, disconnects, returns 429, or returns 5xx	Keep the task ID/type and query the same task later	FAILED, or a reason to create a second paid task
A download URL expires	Local copy, task ID, retention window	A reusable permanent asset URL
Imported scale or collision is wrong	Units, origin, export, Unreal collision settings	Necessarily a bad generated model

After two failed fixes to the same symptom, roll back to the last accepted checkpoint and split the task further. Do not stack a third speculative repair on top of two unverified ones.

Keep three separate usage ledgers

Do not convert “19% of a weekly Max plan” into API tokens. One community creator reported that a first full build took about four hours and roughly 19% of a weekly Max plan. That is an individual report for one project and configuration, not a time, price, or quota promise.

Route	Mandatory item to verify separately	What it does not include	Evidence
Claude Code with a Claude subscription	Plan tier, session or weekly limit, active model	Meshy credits or a model API bill	Claude Code model and usage views
Claude Code with a model API	API key, actual model ID, input/output/cache tokens, balance	Claude Max weekly usage or Meshy	Provider request and billing records; BetterToken users can review model and token records
Optional Meshy asset work	MESHY_API_KEY, eligible paid plan/API access, prepaid API credit balance, and per-task usage	Model API tokens; a web-app allowance is not proof of API balance	meshy_check_balance, task records, and billing
Unreal, Blender, plugins, and content	Current licenses, hardware, marketplace assets, third-party plugin costs	Any assumption that the whole stack is free	Current official terms and purchase records

Before scaling, measure one level: prompt count, retries, model requests, optional Meshy task IDs, downloaded files, and human Play time. The core workflow must repeat Play gates A–C reliably; require D only when Meshy is selected and E only when the Blender/import branch is selected. Expand after the gates for the branches you actually use are stable.

Final checklist

• A rollback point exists before the session and after every accepted gate.
• A real read-only Unreal call succeeded in addition to /mcp showing connected.
• You can walk the route, collect exactly three items, win correctly, and restart from any state in Play.
• PIE is stopped before editor asset changes, and compilation finishes before the next step.
• Meshy and Blender remain optional until the greybox works.
• If Meshy was used, its output is local and the task ID, task type, and final status are recorded.
• If an external asset replaced a primitive, Play gates A–C were rerun.
• The actual model, model tokens, Claude subscription allowance, and Meshy credits are checked separately.

The result is not merely an impressive AI demo. It is a recoverable, observable workflow you can repeat and extend without losing track of what actually works.