The Forge in the Terminal: Pairing Claude Code with Unreal Engine
An earlier post made one claim louder than the rest: the engine is the second decision, and the first is what kind of game your book wants to be. Suppose you answered honestly and the answer was Unreal, because your world is a place more than a plot, a cathedral of ash you want a player to walk through rather than read about. Nothing else within a solo author’s reach renders that as well.
Then you open the editor, and the wall is right there. Unreal runs on C++ and Blueprints, the interface has a thousand panels, and the distance from your idea to something that compiles is measured in months you do not have. This is where most book-to-game projects quietly die. The pairing in this post exists to get you past that wall without becoming a programmer: Claude Code works inside your project as the builder, and you stay the director. It is the same trade the recent posts keep describing, the machine taking the grunt work and handing back the part that was yours, aimed now at the most punishing production wall an author can hit.
Why Learning the Engine Is the Wrong Move
The instinct, once you commit to Unreal, is to go learn Unreal: buy the course, grind the tutorials, spend half a year getting fluent in C++ and the Blueprint graph. Resist it. The code that spawns an actor, the graph that opens a door, the boilerplate wiring an input to an action, all of it is necessary, none of it is the part of the game anyone will remember, and all of it is what an agent now produces on request.
Treat the engine the way you already treat prose. You do not need to write every functional sentence yourself; you need to know whether the result is right and to say exactly what right means. Here that means knowing the door should be heavy, should resist, should open on a delay that makes the player wait a beat too long, because the dread lives in that beat. Claude Code can write the door in a minute. Only you can call for the delay. Spend your hours there.
The reframe is small and total. You are not becoming a programmer who leans on AI; you are directing a builder who happens to program, and what you bring is intent, judgment, and taste, none of which compile.
How the Pairing Is Wired
Claude Code is an agent that lives in your terminal, sits inside a project folder, reads and edits the files, runs commands, and reads the output back to correct itself. An Unreal project is just a folder of files: C++ under Source, the .uproject, config, content. Point the one at the other and it can work your game the way it works any codebase. Three connections turn that from editing text near a game into actually driving the engine.
The C++ source. This is the most direct surface. Claude Code edits your gameplay classes, your actors and components and subsystems, exactly as it edits any C++, then generates the project files, runs the build, and feeds the compiler errors straight into its next attempt. Write, build, read the error, fix, repeat is the loop agents run best, because the compiler is an oracle that says precisely what is wrong and the agent will keep asking until the answer comes back clean. You watch it happen instead of typing it.
The live editor, through MCP. Below the C++ is the running editor itself, and as of Unreal 5.8 the way in is first-party. The engine now ships experimental Model Context Protocol support: a server that runs inside the editor and exposes its systems, actors and Blueprints and materials and meshes and levels and Sequencer, as tools an agent can call. Claude Code talks to that server and works the editor directly, spawning and placing actors, configuring assets, laying out a scene, reading back what changed, the same observe-and-correct loop it runs against the compiler. The underlying machinery is the Python automation layer Unreal has exposed for years; what is new is that you no longer bolt the bridge together from community projects. Epic ships it, which is most of why this pairing is worth writing about now and was not a year ago.
The project as a repository. Put all of it under version control. Every change the agent makes is a commit you can read and undo, and that is the rail that makes handing an agent the keys to a complex engine survivable: a build it breaks is one command to roll back, and a system it implements badly is a diff you read before you keep.
Wiring it up, as of 5.8, is short. In the editor, enable two plugins, ModelContextProtocol and AllToolsets, and switch on Auto Start Server under Editor Preferences, which binds the server to a local port (8000 by default) so it comes up with the editor; you can also start it by hand with the ModelContextProtocol.StartServer console command. Then install Epic’s official Claude Code plugin for Unreal, which adds a skill teaching Claude Code the editor’s toolsets and a session hook that flags the project as Unreal so the agent reaches for Unreal conventions by default. Open Claude Code in the project folder, check that it lists the editor as a connected server, and start directing. The whole bridge is two plugins, a checkbox, and an install, work that was a weekend of research a year ago.
From there the work takes a simple shape. You describe a piece of the game in a sentence or two; the agent reads the relevant parts of the project, edits the C++ or calls the editor tools, builds or runs, reads its own errors, and comes back with a working result or a real question. The request reads less like code than like direction:
“In the cathedral level, the main door should be heavy and resist the player. Spawn it from the existing Door class, give it a slow two-second open with a low groan, and gate it behind the player holding the interact button rather than tapping it. Build, run the editor script to place it at the nave entrance, and show me the diff before you commit anything.”
You direct, you review, you correct, and you almost never type engine code yourself.
Teach the Project What It Is
The highest-leverage thing you can do is write the file that tells the agent what the project is. Claude Code reads a CLAUDE.md at the project root as standing context, and a project with a good one behaves like a builder who has studied your design document instead of a contractor guessing from the code in front of him.
Put in it what the agent cannot infer. The engine version and the build commands that actually work on your machine, so it stops guessing. The architecture: which systems own what, where gameplay code ends and editor tooling begins. The conventions you want kept, the names and patterns worth copying. And the one thing only you have, the feel: that this is a slow, heavy, dread-soaked walk and not an action game, so that when the agent reaches for a default it reaches for yours. Left alone, it drifts toward the average; the CLAUDE.md is where you tell it where your center sits, and that file pays out on every task after. Spend real time on it.
Split the Builder Into Specialists
A whole game is too much to hold in one conversation, and the work cuts along a natural grain. Claude Code can run focused subagents, and an Unreal project divides cleanly: gameplay systems in C++, scene and level assembly through the editor tools, asset and material wiring, build and packaging. The reason to separate them is not tidiness but that each has its own test for being done. Gameplay code is wrong when it fails to compile or does the wrong thing; a level is wrong when it does not feel right, which only your eye catches. Give the scene work its own context and its own slice of intent, and the agent on it can think about atmosphere rather than juggle that against a memory leak somewhere else. You become the lead who routes the work and integrates what comes back, which is what directing a build actually is.
Where It Helps and Where It Will Bite
Be clear-eyed: an agent this capable can also build you an expensive mess.
It shines wherever feedback is fast and honest. C++ that must compile is the best case, the compiler brutal and immediate, the agent grinding at it until it comes clean. The editor tools are strong for the same reason, since an operation either places the thing or throws. Repetitive setup, boilerplate, the hundredth variation on a placement, it does all of this faster and more patiently than you will, and without the boredom that makes a human cut corners.
It goes blind where the feedback goes quiet. No tool can tell you whether the cathedral reads as sacred and abandoned or merely empty, whether a slow walk builds dread or just wastes a minute, whether the light through the broken roof falls holy or flat. None of that compiles. The only signal is your eye in the running game, and if you do not look, nothing in the loop will catch a scene that works technically and dies emotionally. Left loose on a vague instruction, the agent will also cheerfully build three half-systems that each almost do what you asked, because it is chasing a result that looks finished rather than the restraint that keeps a project finishable. The compiler catches broken code; only you catch sprawl.
Treat the 5.8 support as what it calls itself, experimental. The tool schemas will move between releases and the surface will grow, and the thing most likely to come back subtly wrong is Blueprint wiring, where a graph can look plausible and behave a little off, so read the visual logic instead of trusting it the way you trust compiled code. None of that is a reason to wait, only to keep version control tight and your eye on the result, which you were doing anyway. The trajectory is clear too: Unreal 6.0, in preview later this year, pushes AI-assisted authoring further into the editor, so the surface you learn to direct now only widens.
Under all of it runs one line: the agent owns what a machine can verify, you own what only a person can judge. Hold it and the pairing multiplies you. Lose it and you ship something that compiles, runs, and is dead inside, which is the most expensive way to fail.
Adaptation Is Still Subtraction
The hardest discipline from that earlier post survives this one, and the agent raises the stakes on it. What separates a small game that ships from a big one that gets abandoned is treating adaptation as subtraction: carving the book down to the single chamber that can become an unforgettable ten minutes, rather than porting the whole world badly. An agent that will build anything you describe tempts you toward scope harder than a blank engine ever did, because the friction that used to stop you, months of learning per system, is gone, and that friction was quietly doing your discipline for you.
So do it yourself now that the engine will not. Pick the one place, the one sequence, the experience small enough to finish and strong enough to matter, and aim the whole forge at it. The agent has no idea your scope is too large; it will build whatever you name. Naming the small thing and refusing the big one is the director’s call, and it stays yours.
The Forge and the Hand
Pairing Claude Code with Unreal will not turn an author into a studio, and anyone selling it that way is lying. What it removes is one specific wall, the gap between an author’s idea and engine code that author could never write fast enough. With the wall gone, what is left is the part adaptation was always about: what the place is, how it feels to stand in it, which ten minutes of your world earn the right to be walked instead of read.
The forge does the metalwork now. The hand that decides the shape, that knows the door should make the player wait a beat too long, is still yours, and it was always the only part that mattered. Build the one chamber. Make it the thing readers tell each other to go and stand inside. Hand the agent everything that compiles, and spend yourself on the parts that never will.
