How does Atlas understand Unreal Engine C++ code structure?

Atlas indexes Unreal Engine C++ code using tree-sitter for AST declarations, allowing it to understand UCLASS, UPROPERTY, and UFUNCTION macros, as well as `Build.cs` module dependencies, providing deep structural context for reviews.

Can Atlas run Unreal Engine tests during a PR review?

Yes, Atlas can run `Unreal Automation Framework` tests through `UnrealEditor-Cmd` using its `bash` tool, reporting findings as a `todowrite` list, all behind a permission prompt to ensure developer control.

How does Atlas handle Unreal Engine code formatting?

After approving changes, Atlas can apply the engine's `.clang-format` configuration to ensure the code adheres to the Epic style guide, maintaining consistent formatting across your Unreal Engine project automatically.

What safety features does Atlas offer for Unreal Engine development?

Atlas operates with permission-gated tool calls (allow, ask, deny), drafts plans in a read-only agent, and presents a unified diff for approval before writing any changes to your Unreal Engine codebase, ensuring full control.

How does Atlas find references for changed Unreal Engine C++ signatures?

Atlas uses its `lsp` tool's `findReferences` operation to check for callers that might be broken by a changed UFUNCTION or UPROPERTY signature, even if those callers are outside the immediate diff, preventing silent breakages.

Does Atlas integrate with Unreal Build Tool?

Yes, Atlas understands `Build.cs` module rules and can be instructed to add module dependencies before modifying includes, a crucial step for correct compilation and dependency management in Unreal Engine projects.

Can Atlas help catch bugs beyond a simple diff in Unreal Engine?

Absolutely. By reading full files, running `lsp` for references, and `grep`ing for patterns, Atlas catches bugs that a line-by-line diff would miss, especially in Unreal Engine's complex C++ and reflection system, providing comprehensive review.

Review a pull request in Unreal Engine with Atlas in 2026

Atlas empowers Unreal Engine developers in 2026 to review pull requests with deep contextual understanding, going beyond line-by-line diffs. It integrates directly with your Unreal Engine C++ projects, understanding UCLASS macros, `Build.cs` module rules, and leveraging `Unreal Automation Framework` for testing, ensuring a thorough and accurate review process.

How Atlas reviews Unreal Engine pull requests

In 2026, Atlas reviews Unreal Engine pull requests by adopting a human-like approach: it first fetches the diff, then leaves it to gather broader context. This involves using `bash` to produce the raw patch, `read` to pull full files, and the `lsp` tool's `findReferences` to check for broken callers, ensuring a comprehensive review beyond just 10-20 lines of changes.

Atlas's core philosophy for pull request review in Unreal Engine is to move beyond a superficial line-by-line diff. It starts by using its VCS layer to expose `diffRaw` and `diff` data, allowing it to fetch the specific branch and produce the initial changes. However, Atlas immediately expands its scope by using the `read` tool to pull the full content of changed files, not just the hunks. This is crucial for Unreal Engine C++ projects, where context outside the immediate diff can reveal subtle issues related to UCLASS macros, UPROPERTY declarations, or UFUNCTION implementations. For every changed function signature, Atlas leverages the `lsp` tool's `findReferences` operation to identify and check any callers that the diff itself might not show, preventing silent breakages in the complex Unreal Engine codebase. This comprehensive approach ensures that Atlas catches bugs that a simple diff would inevitably miss.

Deep contextual analysis for Unreal Engine C++

Atlas provides deep contextual analysis for Unreal Engine C++ by indexing code with AST declarations using tree-sitter, not blind line windows, a capability vital in 2026. This allows it to understand the intricate relationships within UCLASS, UPROPERTY, and UFUNCTION macros, as well as the dependencies declared in each `Build.cs` file, offering a 360-degree view of your project.

Understanding the unique structure of Unreal Engine C++ is paramount for effective review, and Atlas excels here. It builds its code index by parsing AST declarations using tree-sitter, rather than relying on generic line windows. This enables Atlas to deeply comprehend the significance of UCLASS, UPROPERTY, and UFUNCTION macros, which are fundamental to Unreal Engine's reflection system. Furthermore, Atlas is configured to read and interpret the dependencies declared within each `Build.cs` file, which defines the module rules for your project. This understanding allows Atlas to identify potential issues where a change might break a module dependency or introduce an include without first adding the necessary module dependency in `Build.cs`,a common pitfall for C++ agents. By grasping these Unreal Engine specific idioms, Atlas ensures that its analysis is relevant and accurate for your project.

Verifying changes with Unreal Automation Framework

Atlas can directly run `Unreal Automation Framework` tests to verify changes in your Unreal Engine project, a critical step for quality assurance in 2026. All test executions are permission-gated, requiring your approval before Atlas runs them through `UnrealEditor-Cmd`, and findings are reported as a `todowrite` list, ordered by severity, for clear action.

A robust pull request review includes thorough testing, and Atlas integrates directly with the `Unreal Automation Framework`. Using its `bash` tool, Atlas can execute `Unreal Automation Framework` tests by invoking `UnrealEditor-Cmd` behind a permission prompt. This ensures that any proposed changes are validated against your project's existing test suite. Before running, Atlas will draft a plan in a read-only agent and ask for your explicit permission, adhering to its `allow`, `ask`, and `deny` rules. Once tests complete, Atlas reports its findings as a `todowrite` list, which is ordered by severity, making it easy for you to prioritize and address any regressions or new issues identified. This capability allows Atlas to not only analyze code but also to actively verify its correctness within the Unreal Engine environment.

Ensuring Unreal Engine code style with clang-format

Maintaining a consistent code style is crucial for large Unreal Engine projects, and Atlas helps enforce this by applying the engine's `.clang-format` configuration. After you approve the diff, Atlas can automatically format the code to match the Epic style guide, ensuring adherence to established standards in 2026 and beyond, with zero manual effort.

The Epic style guide is a cornerstone of Unreal Engine development, and `clang-format` is the tool used to enforce it. Atlas direct integrates this into the review workflow. After you have reviewed and approved the unified diff of the proposed code changes, Atlas can be instructed to apply the engine's `.clang-format` configuration. This ensures that all modified files conform to the Epic style guide, maintaining consistency across your Unreal Engine codebase. This step is performed after your approval, giving you full control over the changes before formatting is applied. By automating this, Atlas helps developers focus on the logic and functionality of their pull requests, confident that the final code will meet the required stylistic standards without manual intervention.

Safety and control in Atlas for Unreal Engine reviews

Atlas prioritizes safety and developer control in Unreal Engine pull request reviews through a multi-layered permission system. Every Atlas tool call is permission-gated against `allow`, `ask`, and `deny` rules, and it drafts a plan in a read-only agent before executing any changes, ensuring you maintain full oversight in 2026.

Developer control and safety are paramount when an AI agent interacts with your Unreal Engine codebase. Atlas is designed with this in mind. Every tool call, whether it's `bash` for running tests or `lsp` for finding references, is permission-gated against configurable `allow`, `ask`, and `deny` rules. Before Atlas performs any action that modifies your project, it first drafts a comprehensive plan in a read-only plan agent. This plan is presented to you for review and approval, preventing any unintended changes. Only after your explicit consent does Atlas switch to a build agent to execute the plan. Furthermore, for every file edit, Atlas computes a unified diff and surfaces it for your approval before writing any changes to disk. This meticulous process ensures that you, the Unreal Engine developer, always have the final say and complete transparency over Atlas's actions, safeguarding your project's integrity.

Step by step

01Fetch the pull request branch and generate the raw diff using Atlas's VCS layer, leveraging `bash` to produce the initial change set for your Unreal Engine project.
02Read the full changed Unreal Engine C++ files with Atlas's `read` tool, not just the hunks, to gain complete surrounding context for UCLASS macros and other declarations.
03For every changed UFUNCTION or UPROPERTY signature, use Atlas's `lsp` tool's `findReferences` operation to check for broken callers across your Unreal Engine codebase, even those outside the immediate diff.
04Grep for old constant names, stale copies, or feature flags that should have been updated but were missed in the Unreal Engine C++ files, using Atlas's `grep` tool.
05Ask Atlas to add any necessary module dependencies in `Build.cs` before it modifies includes, a critical step for correct compilation in Unreal Engine projects.
06Run `Unreal Automation Framework` tests via Atlas's `bash` tool and `UnrealEditor-Cmd` to validate changes, reporting findings as a `todowrite` list ordered by severity.
07Approve the unified diff presented by Atlas for all proposed code changes, ensuring full transparency before any modifications are written to your Unreal Engine project.
08Let Atlas apply the engine's `.clang-format` configuration to ensure the code adheres to the Epic style guide, maintaining consistent formatting across your Unreal Engine C++ files.

Frequently asked questions

How does Atlas understand Unreal Engine C++ code structure?: Atlas indexes Unreal Engine C++ code using tree-sitter for AST declarations, allowing it to understand UCLASS, UPROPERTY, and UFUNCTION macros, as well as `Build.cs` module dependencies, providing deep structural context for reviews.
Can Atlas run Unreal Engine tests during a PR review?: Yes, Atlas can run `Unreal Automation Framework` tests through `UnrealEditor-Cmd` using its `bash` tool, reporting findings as a `todowrite` list, all behind a permission prompt to ensure developer control.
How does Atlas handle Unreal Engine code formatting?: After approving changes, Atlas can apply the engine's `.clang-format` configuration to ensure the code adheres to the Epic style guide, maintaining consistent formatting across your Unreal Engine project automatically.
What safety features does Atlas offer for Unreal Engine development?: Atlas operates with permission-gated tool calls (allow, ask, deny), drafts plans in a read-only agent, and presents a unified diff for approval before writing any changes to your Unreal Engine codebase, ensuring full control.
How does Atlas find references for changed Unreal Engine C++ signatures?: Atlas uses its `lsp` tool's `findReferences` operation to check for callers that might be broken by a changed UFUNCTION or UPROPERTY signature, even if those callers are outside the immediate diff, preventing silent breakages.
Does Atlas integrate with Unreal Build Tool?: Yes, Atlas understands `Build.cs` module rules and can be instructed to add module dependencies before modifying includes, a crucial step for correct compilation and dependency management in Unreal Engine projects.
Can Atlas help catch bugs beyond a simple diff in Unreal Engine?: Absolutely. By reading full files, running `lsp` for references, and `grep`ing for patterns, Atlas catches bugs that a line-by-line diff would miss, especially in Unreal Engine's complex C++ and reflection system, providing comprehensive review.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

Atlas for Unreal Engine: Terminal-Native AI Coding for UCLASS and Build.cs in 2026

Atlas is a terminal-native AI coding agent for Unreal Engine C++ in 2026, where UCLASS macros, the reflection system, and Build.cs module rules are the real API.

Document a Module README in Unreal Engine with Atlas in 2026

Learn how Atlas, the terminal-native AI coding agent, helps Unreal Engine developers in 2026 generate accurate README documentation for modules by analyzing UCLASS, UFUNCTION, and Build.cs files.

Extract a Shared Helper from Duplicated Code in Unreal Engine with Atlas in 2026

Refactor Unreal Engine C++ code in 2026 by extracting shared helpers from duplicated logic using Atlas. Find near-duplicates, create new modules, and apply changes with full diff review, all while integrating with

Migrate a Deprecated API Across Every Callsite in Unreal Engine with Atlas in 2026

Migrate deprecated Unreal Engine APIs across your entire codebase with Atlas in 2026. Ensure every callsite is updated using `lsp`, `todowrite`, and `apply_patch`, verified by `Unreal Automation Framework` and

Automate GitHub issue and pull request triage in Unreal Engine with Atlas in 2026

Automate GitHub issue and pull request triage for Unreal Engine projects with Atlas in 2026. Safely respond to events, manage dependencies with Unreal Build Tool (Build.cs), and format code with clang-format, ensuring

Refactor a Legacy Unreal Engine Module in 2026 with Atlas

Learn how Atlas helps Unreal Engine developers refactor legacy C++ modules in 2026. Safely restructure code, manage dependencies with Build.cs, and verify behavior with Unreal Automation Framework.

Self-review your working diff before committing in Unreal Engine with Atlas in 2026

Catch your own mistakes in Unreal Engine C++ code before committing with Atlas. Review uncommitted diffs, run Unreal Automation Framework tests, and apply clang-format for Epic style.

Browse this resource hub