# Review a Pull Request in Elixir with Atlas in 2026

> Atlas enhances Elixir pull request reviews by providing full file context and verifying changes against ExUnit via mix test to catch subtle bugs.

Atlas empowers Elixir developers in 2026 to review pull requests with unparalleled depth, moving beyond line-by-line diffs by fetching full file context, analyzing mix.exs dependencies, and executing ExUnit via mix test to proactively identify bugs that a simple diff might miss.

## Key takeaways

- Atlas integrates deeply with Elixir's `mix` toolchain for comprehensive PR reviews.
- `ExUnit via mix test` is automatically run by Atlas to validate Elixir code changes.
- Atlas uses `lsp findReferences` to detect breaking Elixir function signature changes.
- Full Elixir file context is read by Atlas, not just diff hunks, for better understanding.
- User approval is required for all Atlas actions and proposed Elixir code edits.

## How Atlas Fetches Elixir Diffs and Full File Context

Atlas in 2026 fetches Elixir pull request diffs using its VCS layer, then reads entire changed files, not just hunks. This approach ensures developers see the full context around a modification, crucial for understanding impacts on mix.exs configurations or OTP application structures.

Atlas's VCS layer exposes status, diff, diffRaw, and commits over the same git data, enabling a thorough review process for Elixir projects. This allows Atlas to first produce the raw patch with its `bash` tool, then use the `read` tool to pull the full contents of the changed Elixir files. This is vital because a line-by-line diff often obscures the broader architectural implications within an Elixir GenServer or a Supervisor tree. For instance, a change in `lib/my_app/my_module.ex` might seem minor in a diff hunk, but its full file context reveals its role in a larger OTP application. By reading the complete file, Atlas ensures that modifications to a function signature are viewed alongside its module attributes, behaviors, and surrounding function clauses, providing a comprehensive understanding that a simple diff cannot. This deep contextual awareness is key to catching subtle bugs in complex Elixir codebases.

## How Atlas Validates Elixir Function Signatures with LSP

In 2026, Atlas leverages the lsp tool to validate Elixir function signature changes, specifically using findReferences. This ensures that modifications to a public function in lib/my_app/api.ex do not inadvertently break callers across the OTP application, even if those callers are not part of the immediate diff.

Atlas's `lsp` tool is critical for Elixir pull request reviews, especially when dealing with the language's functional paradigm and pattern matching. When a developer modifies a function signature in an Elixir module, for example, changing `def my_function(arg1)` to `def my_function(arg1, arg2)` in `lib/my_app/data_processor.ex`, the `lsp` tool's `findReferences` operation is invoked. This operation scans the entire codebase, including files not present in the current diff, to identify all call sites. This capability is invaluable for Elixir, where a single function change can ripple through many modules, potentially breaking `case` statements, `with` blocks, or other pattern matches that rely on specific arities or argument structures. Atlas ensures that such breaking changes are caught before they merge, maintaining the integrity of the Elixir application.

## Running Elixir Tests and Formatting with Atlas

Atlas in 2026 integrates directly with Elixir's native toolchain, executing ExUnit via mix test to validate changes and mix format to ensure code style. This ensures that any modification to lib/my_app/feature.ex adheres to project standards and passes all existing tests, providing immediate feedback on code quality.

After analyzing the code and its context, Atlas uses its `bash` tool to run the project's test suite. For Elixir, this means executing `mix test`, which invokes `ExUnit`. This step is paramount for verifying the functional correctness of the changes, ensuring that new features or bug fixes do not introduce regressions. Atlas can also run `mix format` to ensure that the Elixir code adheres to the project's formatting guidelines, which are often configured in `.formatter.exs`. The results from `mix test` are then reported back to the developer as a `todowrite` list, ordered by severity, highlighting any failing tests or warnings. This proactive testing and formatting within the review workflow significantly reduces the chances of introducing quality issues into an Elixir OTP application, making the review process more efficient and reliable.

## Ensuring Safe Elixir Pull Request Reviews with Atlas

Atlas in 2026 prioritizes safety and transparency in Elixir pull request reviews, employing a read-only plan agent and permission-gated tool calls. Before any modification to an Elixir file like lib/my_app/repo.ex is proposed, Atlas drafts a plan and seeks explicit user approval, ensuring full control over the review process.

Atlas's design incorporates several layers of safety for Elixir developers, ensuring that the AI agent acts as a powerful assistant, not an autonomous override. Every Atlas tool call, including `bash` commands like `mix test` or `grep` operations on Elixir source files, is permission-gated against `allow`, `ask`, and `deny` rules. This means a developer has granular control over what Atlas can execute. Furthermore, Atlas first drafts a plan in a read-only plan agent, presenting its proposed actions for review. Only after explicit user approval does it switch to a build agent to execute the plan. For any file edits Atlas might suggest (e.g., formatting fixes from `mix format`), it computes a unified diff and surfaces it for approval before writing, ensuring that changes to `mix.exs` or any Elixir module are fully transparent and reversible. Atlas also snapshots file changes as git patches, allowing edits to be diffed and rolled back if needed, providing an additional layer of security and control for Elixir development.

## Steps

1. Fetch the Elixir branch and generate the diff: Use Atlas's VCS layer to fetch the pull request branch and then `atlas bash git diff origin/main...HEAD` to produce the raw patch for Elixir files.
2. Read full Elixir files for context: Employ the `atlas read` tool to pull the complete contents of all changed Elixir files, such as `lib/my_app/worker.ex`, ensuring context beyond the diff hunks is visible.
3. Validate Elixir function signature changes: For every modified function signature in an Elixir module, use `atlas lsp findReferences` to check for breaking callers across the entire OTP application.
4. Search for stale Elixir patterns: Utilize `atlas grep` to search for old constant names, deprecated module aliases, or feature flags that should have been updated in Elixir files like `config/config.exs`.
5. Run Elixir tests and format checks: Execute `atlas bash mix test` to run `ExUnit` tests and `atlas bash mix format --check-formatted` to verify formatting, reporting findings as a `todowrite` list.
6. Review and approve Atlas's proposed Elixir changes: Examine the unified diffs generated by Atlas for any suggested edits to Elixir code or `mix.exs`, and approve them before writing.

## FAQ

### How does Atlas handle Elixir mix.exs dependency changes during a PR review?

Atlas uses its `read` tool to analyze the full `mix.exs` file, identifying new or updated dependencies. It can then use `bash` to run `mix deps.get` or `mix deps.compile` to ensure the project builds correctly with the changes.

### Can Atlas check for Elixir formatting issues with mix format?

Yes, Atlas can execute `atlas bash mix format --check-formatted` as part of its review workflow. This ensures that all Elixir code adheres to the project's `.formatter.exs` configuration, flagging any deviations before merge.

### How does Atlas ensure I maintain control over Elixir code changes?

Atlas operates with a read-only plan agent and permission-gated tool calls. Any proposed changes to Elixir files, like those from `mix format`, are presented as a unified diff for your explicit approval before being written.

### Does Atlas understand Elixir OTP applications and supervision trees?

Yes, Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand the structure of Elixir OTP applications, including `GenServer` modules, `Supervisor` trees, and contexts defined in `mix.exs`.

### Can Atlas help me find old Elixir feature flags that should be removed?

Absolutely. Atlas's `grep` tool can be configured to search for specific patterns, such as old feature flag names or deprecated module aliases, across your Elixir codebase, ensuring they are properly cleaned up during a review.

### How does Atlas run ExUnit tests for an Elixir pull request?

Atlas uses its `bash` tool to execute the standard Elixir command `mix test`. It then captures the output, reporting any failing `ExUnit` tests or warnings as a prioritized `todowrite` list for the developer.

---

Canonical HTML: https://runatlas.sh/resources/stacks/review-a-pull-request-in-elixir
Source of truth: aeo_pages row `/resources/stacks/review-a-pull-request-in-elixir` (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.