# Review a Pull Request in Assembly with Atlas in 2026 > Atlas helps Assembly developers review pull requests by understanding x86-64 and ARM64 code, checking calling conventions, and integrating with `make check` and `asmfmt`. Atlas empowers Assembly developers in 2026 to review pull requests with unprecedented depth, leveraging its AI capabilities to understand x86-64 and ARM64 code, verify calling conventions, and integrate directly with your `make check` test runner and `asmfmt` formatter. This ensures a comprehensive review that catches subtle bugs a line-by-line inspection might miss. ## Key takeaways - Atlas understands Assembly's unique challenges, including register allocation and calling conventions. - It uses `make check` and `asmfmt` directly, integrating with your existing Assembly toolchain. - Atlas reads full files, not just diff hunks, providing essential context for Assembly reviews. - Permission-gated operations and git patch snapshots ensure safe, controlled modifications to Assembly code. - Semantic search and `grep` help catch subtle, context-dependent bugs in Assembly changes. - Atlas indexes Assembly code by AST declarations, offering a deeper understanding than line-based tools. ## How Atlas Reviews Assembly Code Changes Atlas reviews Assembly code changes in 2026 by first fetching the pull request's branch and generating a raw diff using its `bash` tool. It then goes beyond simple diffs, reading full changed files with `read` to provide crucial surrounding context, a step often missed in traditional reviews. When reviewing an Assembly pull request, Atlas initiates a process that mirrors a meticulous human reviewer. It begins by using its `bash` tool to fetch the specific branch and generate the raw patch, providing the foundational changes. However, unlike a simple `git diff`, Atlas employs its `read` tool to pull the complete contents of all changed files. This is critical for Assembly, where a single instruction change can have far-reaching implications that are only visible with full contextual awareness of surrounding code, register allocation, and memory access patterns. Atlas's ability to index code by AST declarations using tree-sitter, rather than blind line windows, further enhances its understanding of the structural impact of changes in `.asm` or `.S` files. ## Verifying Assembly Calling Conventions and ABI Atlas ensures the integrity of Assembly code by verifying calling conventions and ABI compliance, a critical step for x86-64 and ARM64 architectures in 2026. It uses the `lsp` tool's `findReferences` operation to detect if any changed function signature breaks existing callers. In Assembly, adherence to calling conventions (like System V or AAPCS64) and the Application Binary Interface (ABI) is paramount. Atlas is specifically designed to understand these low-level contracts. For every changed function signature identified in the pull request, Atlas utilizes its `lsp` tool to perform a `findReferences` operation. This powerful capability allows Atlas to check all callers across the codebase, even those not directly touched by the diff, ensuring that a modification to a routine's entry or exit point, or its register usage, does not inadvertently break existing code. This proactive check is vital for maintaining stability in complex Assembly projects where register allocation and stack management are explicit responsibilities. ## Catching Latent Bugs with Contextual Grep and Semantic Search Atlas goes beyond explicit diffs to catch latent bugs in Assembly pull requests in 2026, employing `grep` for pattern matching and its advanced semantic search. This ensures that related, but not directly modified, code sections like old constant names or stale copies are updated consistently across 100s of files. A common source of bugs in Assembly development is the failure to update all relevant code sections when a constant, label, or feature flag changes. Atlas addresses this by using its `grep` tool to search for patterns that the change *should* have updated but did not. This includes old constant names, stale copies of code, or feature flags that might be referenced in multiple `.asm` or `.S` files. Furthermore, Atlas's hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, allows it to search code intelligently, identifying conceptually related areas that might need attention even if they don't match a literal string. This comprehensive approach significantly reduces the risk of introducing subtle, hard-to-find bugs. ## Automated Testing and Formatting for Assembly PRs Atlas integrates automated testing and formatting into the Assembly pull request review workflow in 2026, executing `make check` and applying `asmfmt`. This ensures that all proposed changes not only pass existing tests but also adhere to the project's established coding style, improving code quality and maintainability for 100% of the codebase. After performing static analysis and contextual checks, Atlas proceeds to validate the changes dynamically. It uses its `bash` tool to run the project's test suite via `make check`. This step is crucial for Assembly, where correctness often depends on precise execution and state management. Atlas then reports its findings as a `todowrite` list, ordered by severity, providing actionable feedback. Additionally, Atlas ensures code consistency by applying `asmfmt` to all touched `.asm` or `.S` files, keeping alignment and column style uniform. This automated formatting step, behind a permission prompt, prevents style drift and reduces cognitive load during reviews, allowing developers to focus on logic rather than whitespace. ## Permission-Gated Operations and Rollback Safety Atlas prioritizes safety and control in Assembly pull request reviews in 2026, with every tool call permission-gated against allow, ask, and deny rules. Before any write operation, Atlas computes a unified diff and snapshots file changes as git patches, offering a 2-step approval process and easy rollback. Security and control are paramount when an AI agent interacts with your Assembly codebase. Every Atlas tool call, whether it's running `make check` or applying `asmfmt`, is permission-gated. This means operations are executed only after explicit approval based on configurable allow, ask, and deny rules. Before Atlas writes any changes to your `.asm` or `.S` files, it drafts a plan in a read-only plan agent and asks for approval. Once approved, it computes a unified diff for every proposed file edit and surfaces it for a final approval. Furthermore, Atlas snapshots all file changes as git patches, allowing for easy diffing and rolling back of edits, providing a robust safety net for critical Assembly code. ## Steps 1. Fetch the pull request branch and generate the raw diff using Atlas's `bash` tool to get the changed files and patch. 2. Use Atlas's `read` tool to pull the full contents of all changed `.asm` or `.S` files, ensuring complete surrounding context is available for review. 3. For every modified function signature in the Assembly code, instruct Atlas's `lsp` tool to run `findReferences` to identify and check all affected callers, verifying ABI and calling convention compliance (System V, AAPCS64). 4. Employ Atlas's `grep` tool to search for old constant names, stale code copies, or feature flags that should have been updated in `.asm` or `.S` files but were missed. 5. Execute the project's test suite using Atlas's `bash` tool with the command `make check` to validate the functional correctness of the Assembly changes. 6. Have Atlas apply the `asmfmt` formatter to all touched `.asm` or `.S` files to maintain consistent alignment and column style, ensuring code quality. 7. Review Atlas's findings, presented as a `todowrite` list ordered by severity, and approve or adjust proposed changes with its permission-gated workflow. ## FAQ ### How does Atlas understand x86-64 and ARM64 Assembly calling conventions? Atlas is configured to recognize and interpret common Assembly calling conventions like System V for x86-64 and AAPCS64 for ARM64. It uses this knowledge, combined with AST indexing, to analyze register usage and stack frame manipulation, ensuring changes adhere to the established ABI. ### Can Atlas run my custom Assembly test suite with `make check`? Yes, Atlas integrates directly with your existing build system. You can instruct Atlas to execute `make check` via its `bash` tool, and it will report the test results as part of its review findings, just as a human developer would. ### What if Atlas proposes a change to my `.asm` file? Is it safe? Atlas operates with a strong emphasis on safety. Any proposed changes to your `.asm` or `.S` files are first drafted in a read-only plan agent. Before writing, Atlas presents a unified diff for your approval and snapshots the original file as a git patch, allowing for easy rollback if needed. ### How does Atlas ensure my Assembly code style remains consistent? Atlas uses the `asmfmt` tool to automatically format any `.asm` or `.S` files it touches during a review. This ensures that your Assembly code adheres to predefined style guidelines, maintaining consistent alignment and column style across your project. ### Can Atlas find bugs in Assembly code that aren't directly in the diff? Absolutely. Atlas goes beyond the immediate diff. It reads full files for context, uses its `lsp` tool to find references to changed signatures, and employs `grep` and semantic search to identify related code sections (like old constants or feature flags) that might require updates, even if they weren't part of the original patch. ### Does Atlas support both NASM and GNU Assembler syntax? Atlas is designed to work with your project's existing Assembly toolchain. It can be configured to assemble your code using either `nasm` or the GNU assembler, adapting to your specific development environment and syntax requirements for `.asm` or `.S` files. ### How does Atlas handle complex Assembly macros or inline assembly? Atlas indexes code by AST declarations using tree-sitter, which provides a structural understanding of your Assembly code, including labels, sections, and routine definitions. While direct macro expansion isn't its primary function, its deep code understanding helps it reason about the impact of changes within complex Assembly constructs. --- Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-assembly Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-assembly` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.