Three shifts in your day.
The loop closes without you
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."
The codebase answers questions
"Where is fall damage actually calculated?" is a ten-second question now. Onboarding to an unfamiliar system means asking, not spelunking.
Grunt work stops being your job
Boilerplate classes, migration passes, log spelunking, PR descriptions, header cleanups — delegate all of it. Save your brain for architecture and feel.
The playbooks you'll use most.
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 & replication
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.
The unreal-cpp playbook is only as good as its last correction.
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 →
Claude with its hands on the editor.
The Unreal MCP is a live bridge into the running editor. For engineering, that means Claude can do things no code-only assistant can:
Run and observe
Launch PIE, read actor properties at runtime, tail the output log, and screenshot the viewport. Your change gets watched, not assumed.
Touch the binary world
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.
Reproduce before fixing
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.
End prompts with "prove 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.
The rest of the job gets faster too.
PRs & tech docs
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.
Rubber-duck with receipts
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."
Learning the engine
"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.
Give Claude a compiler's eyes, and every crash the team hit.
clangd-lsp is the highest-leverage thing on this list. Install it and the language server reports type errors, missing includes, and syntax problems back to Claude after every edit it makes — so it catches and fixes its own mistakes in the same turn, instead of you finding them when the build breaks. Plus real jump-to-definition and find-references instead of grep.
Sentry is the other one. It has a first-class Unreal SDK, so crashes from real builds on real machines land in one place — which promotes log-and-crash-triage from "read the log on my desk" to "read every crash the player base hit, and tell me which changelist caused it." And Perforce closes Claude's last big blind spot: it can read our files but currently knows nothing about the depot they came from.