Terminal
Terminal/Skill
Helps write Unreal Engine C++ classes, components and gameplay code in a project open in JetBrains Rider, checked with its build and symbol tools.
By JetBrains
Works with
npx skills add jetbrains/rider-skills --skill ue-code-authoringImplement Unreal Engine C++ changes in the project's own style. Write the code with your own file tools, audit the result against what the user actually asked for, and use Rider only for what an IDE knows and grep does not: resolved symbols, reflection/UHT diagnostics, solution code style, and builds.
Rider is reached through a single MCP tool — execute_tool(command="<tool> --flag value ...").
Glob for *.uproject at the root. If there is none, stop and say the task must run from the UE project root..uproject, the relevant Source/<Module>/<Module>.Build.cs, and one or two nearby .h/.cpp files that already do the same kind of thing.A change is done when two independent things hold, and they fail for different reasons:
A green C++ build and Blueprint compile prove neither. Most of the risk sits in (2), because gameplay code is exercised not only by the running game but by callers that construct objects programmatically with none of the game's setup around them — see Programmatic-use invariants below. Shape is cheap to check and cheap to fix; behaviour under minimal construction is where working-looking code breaks.
If the task exposes existing test sources for the surface you are changing, read them the way you'd read any other caller: they show the shapes and entry points that must keep working.
Before the first build, turn the requested surface into a short literal checklist and point at the exact declaration or branch that satisfies each item. Do not substitute an equivalent-looking abstraction for a named mechanism. In particular:
BlueprintReadOnly property,
not only through a getter;.cpp, including the inactive/no-op path;Only after this audit may a build be treated as validation evidence.
Gameplay code gets driven from contexts far barer than a running match: automated tests, editor
commandlets, and tools routinely build the minimum they need — a bare world, a plain actor, a
component made with NewObject — and nothing else. No avatar or skeletal mesh, no player controller,
no network authority, no loaded content, no initialised gameplay framework. Code that works in the
running game routinely fails there, and it fails hard: a failed checked cast takes down the whole
process rather than returning an error.
Write for that environment — it is also what makes the feature testable at all:
| Job | Use |
|---|---|
| Find files by name or glob | Glob |
| Find text on disk (identifiers, macros, tag strings) | Grep |
| Read a file, or a range of it | Read (with offset/limit) |
| Create or change source | Write / Edit |
| Resolve a symbol the IDE index knows (engine headers, generated/reflected code, external modules) | Rider search_symbol |
| Code analysis, solution formatting, build | Rider get_file_problems, lint_files, reformat_file, build_solution_* |
| Refactor existing code (rename, move, change signature, safe delete, extract) | Rider refactoring tools |
Do not shell out through Bash for rg, find, sed, cat, head, or tail — the dedicated tools are cheaper and give clickable results. Keep Bash for git and for toolchain commands the task genuinely requires.
Use TodoWrite only when the change spans three or more files or has ordered dependencies; a single-file edit does not need a checklist. For wide pattern discovery in a large UE codebase ("how does this project register native gameplay tags", "where are attribute sets defined"), one Explore subagent is worth it — but keep the edits, the compliance audit, and the diagnostics in the main thread where you can see the source.
execute_tool(command="search_symbol --q UMyGameplayComponent")
execute_tool(command="get_file_problems --filePath Source/MyModule/MyGameplayComponent.cpp")
In Claude Code the tool name is namespaced by the MCP server key from the environment's config — mcp__<key>__execute_tool. The key is not knowable in advance: rider in a local IDE, ide-headless-mcp in a headless eval container, jetbrains or ide elsewhere, and it may contain hyphens. The same skill run therefore sees a different name in each environment. Never type a prefix from memory. Resolve it once, by bare name:
ToolSearch(query="+execute_tool", max_results=5)
+<bare_name> requires that substring in the tool name and ignores the prefix, so one call returns the exact namespaced name and its schema. Call that name back verbatim and reuse the same prefix for the rest of the session. If several servers match, take the one whose description names the IDE. The same search resolves any other tool in this skill — +lint_files, +get_file_problems — which matters because some configurations expose the individual Rider tools directly alongside the router; a direct typed call beats hand-serializing flags into execute_tool. If nothing matches at all, there is no Rider: keep doing source-level work and state plainly that Rider diagnostics were skipped.
| Need | Command |
|---|---|
| Find a class, method, field, enum, or UE type | search_symbol --q <name> |
| IDE text search when generated/reflected code or compact results matter | search_text --q <text> |
| Check one changed file | get_file_problems --filePath <path> |
| Check several changed files | lint_files --files '["Source/Module/Foo.h","Source/Module/Foo.cpp"]' |
| Rename, move, or re-sign an existing symbol | rename_refactoring, move_type_to_namespace, change_api_signature — --preview true first for public API |
| Reformat changed files | reformat_file --files '["Source/Module/Foo.h","Source/Module/Foo.cpp"]' |
| Build through Rider | build_solution_start, then poll build_solution_state on a ~60s cadence until state is not Running |
| Build only the changed files | build_solution_start --filesToRebuild '["Source/Module/Foo.cpp"]', then poll |
| Project-wide problems after a successful build | get_project_problems |
| Read a file the shell cannot reach (engine, SDK, external module) | read_file --file_path <path> --offset <line> --limit <n> |
Command syntax:
--flag takes a value — bare flags are not supported. Booleans need an explicit true/false.--files '["Source/Module/Foo.cpp"]'.../ reaches outside it, which is how you read engine sources.search_text, search_regex, search_file, and search_symbol all take --q — not --query.--filePath) except read_file, which takes snake_case --file_path. Do not carry a flag name over from a neighbouring tool; that mistake costs a full round trip.read_file on a large or unfamiliar file. The default window is 2000 lines (max 5000), which for a big engine header exceeds the per-result token budget and returns Error: result (… characters …) exceeds maximum allowed tokens — the call is spent for nothing. Locate the symbol first, then read a narrow window around it (--offset <hit line> --limit 60).--offset/--limit.get_file_problems returns errors only by default; add --errorsOnly false when warnings or style suggestions matter to the change.lint_files defaults to --min_severity warning (includes suggestions and hints); --min_severity error is the strict gate.Missing required parameters: … and Tool '<x>' not found are input mistakes, not tool failures — correct the flag or the name and retry once. Fall back to source-only work only if execute_tool is absent or a call actually ran and failed in a way no input change fixes.Edit/Write, then Rider diagnostics.Grep, git diff, or build just to confirm a clean diagnostic, lint, format, or build.Independent execute_tool calls belong in one message — issue get_file_problems for two changed files, or a search_symbol plus a search_text, as parallel calls rather than one round trip each.
Edit/Write the source.get_file_problems per file, in parallel;lint_files call.After Edit/Write there is nothing to save: Rider refreshes each file from disk before it analyzes, formats, or refactors it. Two consequences worth remembering — reformat_file rewrites files on disk, so run it last and Read a file again before editing it further; and if this project installs Rider's PostToolUse quality-check hook, the hook output you already got after an edit is the analysis (it blocks on errors, reports warnings, and skips reformatting for C/C++ while still inspecting it) — fix what it reports instead of re-running the same check.
Use the full quality path only when a local IDE build is the requested or necessary validation. If the build is owned elsewhere, stop after the source audit plus changed-file diagnostics.
get_file_problems / lint_files on changed files → fix errors and relevant warnings.ERROR severity (attribute-accessor macros, check(...) / PLATFORM_BREAK, generated-header symbols). Separate them with one comparison: run the same check on a single untouched neighbour file of the same kind. Identical diagnostic there → resolver noise for the whole project; note the signature once and ignore it for the rest of the session. Do not confirm it against a third and fourth file, and never edit working code to silence it. Anything that does not reproduce on an untouched file is yours to fix.build_solution_start; poll build_solution_state on a ~60s cadence (see Build stop rule); fix build errors in changed files.get_project_problems after a successful build, filtered to changed files.reformat_file on the changed files.When the Unreal toolchain is absent or the build is intentionally left to CI, do not go hunting for engine scripts or hand-run UBT. Spend the turn on correct source, focused checks, and an honest report of what could not be verified.
The terminal build_solution_state result is the build evidence. If it fails because of an
unrelated project or environment error, report that blocker and stop the build loop. Do not use
Bash to inspect Intermediate, Binaries, generated/UHT files, object files, or unrelated
source in an attempt to prove the changed file compiled; those checks cannot turn a failed build
into valid evidence. Only investigate diagnostics that name a changed file.
Poll a build on a slow cadence, not in a tight loop. A UE module build takes minutes.
build_solution_state is safe to call repeatedly and accumulates problems while state is
Running, but every poll is a full turn that re-sends the whole conversation — so a tight poll loop
costs far more context than the same build watched a handful of times. Budget roughly:
build_solution_start to confirm it took.state is Running, wait ~60s between polls — a single Bash sleep 60 is the correct
tool for that wait, and is cheaper than a burst of empty polls.The sessionId is optional — an argument-free call reads the most recent build. Stop as soon as
state is no longer Running. Ignore -Werror problems in files you did not change; a
buildIsSuccess: false caused only by pre-existing unrelated problems is a blocker to report, not to
fix. Start a new build only after you have actually changed source since the last one.
Build until it compiles. A compile error in a file you touched is never an acceptable end state. When the build reports an error in your changed source: fix it, rebuild, and poll again — as many cycles as it takes. Several build-fix cycles is the normal shape of this work, not a sign something has gone wrong; the poll-cadence rule above exists to make each cycle cheap, never to cut the number of cycles short. Do not summarize, hand back, or claim the change is complete while any changed file still fails to compile. The only acceptable stop with a red build is one whose errors are all in files you did not touch — say so explicitly and name them.
Before any build-only validation and before your final message, turn the explicit request into a short acceptance checklist and compare it to the changed source. Clean diagnostics and a green build prove the C++ is valid; they prove nothing about whether the reflected API, metadata, lifecycle behavior, or boundary rules match what was asked.
Check every item that applies:
const, parameter names, enum values, visibility, and out-of-line definitions match the request. If the request names a function and its parameters, call it with those names in implementation paths unless there is a clear reason not to.public: section. Do not demote them to protected:/private: or hide them behind a differently named backing field.UCLASS, USTRUCT, UENUM, UPROPERTY, UFUNCTION metadata sits on the declaration callers and designers will actually use. Keep standard UE metadata spelling and generated-header include order. If designers must read a state or value from Blueprint, expose that state itself as BlueprintReadOnly — not only a C++ getter.BlueprintReadOnly for readable state/config unless mutation was requested; EditAnywhere (or the requested scope) for designer-configurable values; BlueprintAssignable for Blueprint-bindable events.AddDynamic only for dynamic multicast delegates with UFUNCTION handlers; AddUObject only for native multicast delegates that support it; cleanup matched to the exact bind method or the handle it returned.If an item is uncertain, Read the relevant declaration or a narrow range around it. Do not infer prompt compliance from build success. Do not run git diff/git status unless a .git directory exists in or above the workspace.
UCLASS/UPROPERTY metadata, GENERATED_BODY(), and a <MODULE>_API export where other modules, tests, or designers reach the type.TObjectPtr for reflected UObject references in UE5. Never new or delete a UObject.UCLASS Blueprint metadata explicitly on that type rather than relying on inherited defaults.When adding Gameplay Ability System code, read the nearest existing attribute set, gameplay ability, native tag registration, and cost/cooldown pattern first, and match the project's exact macros and lifecycle hooks.
execute_tool argument you are unsure of.