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.

Review a Pull Request in Elixir with Atlas in 2026

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.

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.

Step by step

01Fetch 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.
02Read 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.
03Validate 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.
04Search 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`.
05Run 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.
06Review 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.

Frequently asked questions

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.

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 Elixir in 2026

Adopt Atlas, the terminal-native AI coding agent, for Elixir development in 2026. Enhance productivity with deep code understanding, safety features, and direct integration into mix projects and OTP applications.

Refactor a legacy module in Elixir with Atlas in 2026

Refactor Elixir modules safely in 2026 with Atlas, the terminal-native AI coding agent. Pin behavior with ExUnit via mix test, map callsites with LSP, and apply changes with atomic patches.

Write Unit Tests for Untested Code in Elixir with Atlas in 2026

Learn how Atlas helps Elixir developers in 2026 add robust unit tests to untested modules, matching existing repo conventions using ExUnit via mix test.

Trace a Runtime Bug From a Stack Trace in Elixir with Atlas (2026)

Trace an Elixir runtime bug from a stack trace in 2026 with Atlas: read each frame at its offset, grep for the error message, findReferences the callers, fix, add ExUnit.

Research a Third-Party API Before Integrating It in Elixir with Atlas (2026)

How to research an external API before writing the Elixir client with Atlas in 2026: websearch, webfetch in markdown, then write the module and run ExUnit via mix test.

Debug a Single Failing Test in Elixir with Atlas (2026)

Fix one red ExUnit test in Elixir in 2026, not the assertion. Atlas isolates it with mix test at a line number, walks the call path with lsp, and edits the real code.

Diagnose a Hanging or Long-Running Elixir Command with Atlas (2026)

When mix test or mix deps.get hangs in Elixir, Atlas tells you whether it is slow or blocked on stdin in 2026, then gets it unstuck with a timeout or a CI flag.

Browse this resource hub