Claude has read the whole codebase, knows our C++ conventions cold, can compile and cook the project on its own, and — through the Unreal MCP — can launch the game and watch its own change run before it tells you it's done. Your job shifts from typing code to directing it.
Claude writes the change, compiles it, reads the errors, fixes them, and re-runs the tests. You review a working diff — not a first draft that "should compile."
"Where is fall damage actually calculated?" is a ten-second question now. Onboarding to an unfamiliar system means asking, not spelunking.
Boilerplate classes, migration passes, log spelunking, PR descriptions, header cleanups — delegate all of it. Save your brain for architecture and feel.
Each of these is in the shared library. Claude picks them up automatically when the task fits, or you can call one by name. What matters: these encode our commands, our conventions, our checklists — so Claude works like a Lasting Light engineer, not a generic one.
Browse all Engineering skills in the Library →
Our house conventions on top of Unreal's: when to use UPROPERTY/UFUNCTION and with which specifiers, UObject lifetime and GC rules (TObjectPtr vs TWeakObjectPtr vs raw), module boundaries and Build.cs dependency rules, class prefixes, tick-avoidance policy, async-loading patterns.
Every line of C++ Claude writes for us goes through this playbook — which also makes it your instant code reviewer for anyone's diff, including your own.
Our exact UnrealBuildTool and RunUAT invocations with the project's real flags — editor target, cook, platform packages. Claude runs the build, parses the error output itself, fixes the cause, and rebuilds until it's green.
This is the skill that turns "here's some code, good luck" into "here's a change that compiles and cooks."
The sleeper hit. After any gameplay change, Claude uses the Unreal MCP to launch PIE, query actor state, watch the output log for ensures and errors, and screenshot the scene. It doesn't say "done" — it says "done, and here's the proof."
Other skills end by invoking this one. It's our studio-wide definition of finished.
UE log anatomy, ensure/check semantics, how to symbolicate our platform callstacks, where our crash dumps land — plus a running table of this project's known recurring failures and their fixes.
Paste a crash, get back: the failing code path, the likely cause, whether we've seen it before, and a proposed fix. Triage stops being a senior-engineer tax.
Runs Unreal's Automation framework headless with our filters, and writes new functional tests and specs in our style. Combined with build-and-cook, it closes the full loop: edit → build → test → fix → repeat without a human in the middle.
Blueprints are binary — normally invisible to any AI. Through the MCP, Claude reads graphs node-by-node, reviews the logic against our checklist, and applies our BP-vs-C++ boundary rules: what's allowed to live in Blueprint, and what must move to code when it matures.
Our source-control workflow: how we branch, how changelists get described, how binary assets get locked and released, and how conflicts on unmergeable files get resolved. Claude follows it for every change it lands — and writes better commit messages than most of us.
perf-profiling — capture and read Unreal Insights traces, csvprofiler runs, and stat output against our per-platform frame budgets. replication — our multiplayer patterns: RPC rules, replication conditions, net relevancy, common desync causes. Reach for them when the task is perf or netcode; they work exactly like the ones above.
Caught yourself explaining the same convention to Claude twice — a GC gotcha, a module boundary rule? That's not a one-off correction, it's a gap in the skill. See exactly how to fix it →
The Unreal MCP is a live bridge into the running editor. For engineering, that means Claude can do things no code-only assistant can:
Launch PIE, read actor properties at runtime, tail the output log, and screenshot the viewport. Your change gets watched, not assumed.
Inspect and edit Blueprints, tweak actor properties in the level, run console commands — the half of the project that used to be invisible to tooling.
Hand Claude a bug report and it can attempt the repro itself in the editor first — so the fix targets the actual failure, not a guess about it.
The single highest-leverage phrase in this building. "…then verify it in the editor and show me the log" turns every task from a draft into a deliverable.
PR descriptions from the diff, architecture notes from the code, RFC drafts from a rambling voice memo. Claude writes the first 90%; you edit the 10% that matters.
Stuck on a design decision? Talk it through. Claude pushes back with specifics from our actual codebase, not generic patterns — and it never gets tired of "wait, go back."
"Explain how UE's async loading actually works, then show me where we use it" is a personal engine tutorial, on demand, grounded in our own project.