How does Atlas understand Erlang supervision trees and `gen_server` modules?

Atlas indexes Erlang code by AST declarations using tree-sitter, allowing it to map supervisor callbacks, `gen_server` modules, and `relx` release configurations directly from files like `rebar.config` and `src/*.app.src`.

Can Atlas run `rebar3 eunit` or `rebar3 ct` tests in my Erlang project?

Yes, Atlas can run `rebar3 eunit` and `rebar3 ct` behind a permission prompt. This ensures you approve any test execution before it happens, integrating direct with your Erlang development workflow.

How does Atlas handle Erlang code formatting with `erlfmt`?

After Atlas makes any changes to your Erlang modules, it will run `erlfmt` on those touched files. This action is permission-gated, allowing you to approve the formatting step to ensure consistency with your project's style.

What specific Erlang files does Atlas prioritize for onboarding?

Atlas prioritizes `rebar.config` for build and dependency information, `src/*.app.src` for application definitions, and any Erlang modules identified by `codebase_search` as semantically relevant to your query.

Is it safe to let Atlas explore my unfamiliar Erlang codebase?

Yes, it is safe. The `explore` subagent, used for wide sweeps, operates with a deny-by-default permission set, allowing it only to `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. It cannot modify any Erlang files.

Can Atlas help me add a new `handle_call` clause to an existing `gen_server`?

Yes, Atlas can draft a plan to add a new `handle_call` clause or other Erlang code. It will present a unified diff for your approval before writing the changes and can then run `erlfmt`.

How does Atlas keep my Erlang code private during indexing?

Atlas builds its code index with local Ollama embeddings. This means your Erlang code never leaves your local machine and is not sent to third-party servers, ensuring your intellectual property remains private.

Onboard to an unfamiliar codebase in Erlang with Atlas in 2026

Atlas helps Erlang developers in 2026 build a working mental model of unfamiliar `rebar3` repositories without reading every file by starting from meaning, not filenames, and leveraging specific Erlang toolchain knowledge. It uses semantic search to pinpoint relevant code, maps project structure with `glob`, and allows safe exploration of `gen_server` modules and supervision trees, all while integrating with `rebar3 eunit`, `rebar3`, and `erlfmt` for a native Erlang experience.

How does Atlas build a mental model of Erlang code?

In 2026, Atlas builds a working mental model of an Erlang codebase by starting from semantic understanding, not just file names. It indexes code by AST declarations using tree-sitter, allowing it to map Erlang constructs like supervisor callbacks and `gen_server` modules.

Atlas begins by indexing your Erlang code using AST declarations, which means it understands the structure of your `gen_server` modules, supervisor definitions, and `relx` release configurations. When you ask `codebase_search` a plain-language question, such as "how are requests authenticated?" in an Erlang context, Atlas queries this semantic index. It returns ranked snippets with file paths, prioritizing meaning over keyword matches. This approach helps you quickly identify the core Erlang modules and functions responsible for specific behaviors, like a `handle_call` clause in a `gen_server` or a specific process in a supervision tree, without needing to manually trace every file in a `rebar3` project. Atlas's ability to build its code index with local Ollama embeddings also ensures your proprietary Erlang code remains off third-party servers.

What Erlang files and commands does Atlas use for onboarding?

Atlas leverages specific Erlang file paths and the `rebar3` toolchain to understand project structure. It identifies key files like `rebar.config` and `src/*.app.src` to map application definitions and dependencies, providing a concrete view of your Erlang/OTP system.

To onboard to an unfamiliar Erlang codebase, Atlas first uses the `glob` tool to map the top-level directories, revealing the `rebar3` package layout and naming conventions. It specifically looks for `rebar.config` to understand project dependencies and build configurations, and `src/*.app.src` files to identify application definitions and their versions. After `codebase_search` provides initial ranked files, Atlas uses the `read` tool to pull the two or three most relevant Erlang modules. From there, the `lsp` tool's `goToDefinition` operation allows you to follow module imports and function calls, tracing the flow of execution through `gen_server` behaviors or supervisor children. For instance, if `codebase_search` points to a `gen_server` module, `lsp` can quickly navigate to its `start_link` function or a specific `handle_call` implementation, providing a rapid understanding of its role within the Erlang/OTP system.

How does Atlas explore an Erlang codebase safely?

Atlas ensures safe exploration of an Erlang codebase through its `explore` subagent, which operates with a deny-by-default permission set. This subagent can perform wide sweeps across your `rebar3` project using tools like `grep` and `read` without ever modifying a single Erlang file.

When you need to perform a wide sweep or investigate a broad concept across an unfamiliar Erlang codebase, you can delegate this work to the `explore` subagent through the `task` tool. The `explore` subagent is designed with a deny-by-default permission set, meaning it cannot make any changes to your Erlang files. It is explicitly allowed to use tools like `grep` to search for patterns across modules, `glob` to discover file structures, `read` to inspect file contents, `bash` for basic shell commands, `webfetch` to retrieve external documentation, and `websearch` for broader context. This read-only approach ensures that while Atlas is looking for all instances of a specific `gen_server` callback or tracing how a particular message flows through a supervision tree, your Erlang project remains untouched and secure. This safety mechanism is crucial for building confidence when exploring complex Erlang/OTP systems.

How does Atlas ensure code quality and review for Erlang changes?

Atlas integrates robust review and safety mechanisms for Erlang code changes, including unified diffs and permission prompts for every action. Before any modification, Atlas drafts a plan in a read-only agent and seeks approval, ensuring control over your `rebar3` project.

Atlas provides a secure and transparent workflow for making changes to Erlang code. It first drafts a plan in a read-only plan agent, outlining the proposed modifications, such as adding a new `handle_call` clause to a `gen_server` or creating a Common Test suite under the `test/` directory. You are prompted to approve this plan before Atlas switches to a build agent. Crucially, for every file edit, Atlas computes a unified diff and surfaces it for your approval before writing. This allows you to review the exact changes to your Erlang modules. Furthermore, Atlas integrates directly with the Erlang toolchain: if it proposes adding a test, it will run `rebar3 eunit` or `rebar3 ct` behind a permission prompt. After any code modification, Atlas will run `erlfmt` on the touched modules, also behind a permission prompt, ensuring the diff matches your project's established Erlang style guidelines before it stages and creates commits on your behalf.

Step by step

01Ask `codebase_search` a plain-language question about your Erlang codebase, for example, "how are requests authenticated in this `rebar3` application?"
02Run `glob` on the top-level directories to quickly see the `rebar3` package layout and naming conventions, identifying `src/*.app.src` and `rebar.config`.
03Read the two or three Erlang files `codebase_search` ranked highest using the `read` tool, then follow module imports with the `lsp` tool's `goToDefinition` operation to trace `gen_server` or supervisor logic.
04Delegate wide sweeps to the `explore` subagent through the `task` tool to find all instances of a specific `handle_call` or `gen_server` module, knowing it's read-only.
05Record what you learned about the Erlang system as a `todowrite` list so open questions survive into the next turn.
06If Atlas proposes a code change, review the unified diff and approve `erlfmt` running on the touched Erlang modules to maintain project style.

Frequently asked questions

How does Atlas understand Erlang supervision trees and `gen_server` modules?: Atlas indexes Erlang code by AST declarations using tree-sitter, allowing it to map supervisor callbacks, `gen_server` modules, and `relx` release configurations directly from files like `rebar.config` and `src/*.app.src`.
Can Atlas run `rebar3 eunit` or `rebar3 ct` tests in my Erlang project?: Yes, Atlas can run `rebar3 eunit` and `rebar3 ct` behind a permission prompt. This ensures you approve any test execution before it happens, integrating direct with your Erlang development workflow.
How does Atlas handle Erlang code formatting with `erlfmt`?: After Atlas makes any changes to your Erlang modules, it will run `erlfmt` on those touched files. This action is permission-gated, allowing you to approve the formatting step to ensure consistency with your project's style.
What specific Erlang files does Atlas prioritize for onboarding?: Atlas prioritizes `rebar.config` for build and dependency information, `src/*.app.src` for application definitions, and any Erlang modules identified by `codebase_search` as semantically relevant to your query.
Is it safe to let Atlas explore my unfamiliar Erlang codebase?: Yes, it is safe. The `explore` subagent, used for wide sweeps, operates with a deny-by-default permission set, allowing it only to `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. It cannot modify any Erlang files.
Can Atlas help me add a new `handle_call` clause to an existing `gen_server`?: Yes, Atlas can draft a plan to add a new `handle_call` clause or other Erlang code. It will present a unified diff for your approval before writing the changes and can then run `erlfmt`.
How does Atlas keep my Erlang code private during indexing?: Atlas builds its code index with local Ollama embeddings. This means your Erlang code never leaves your local machine and is not sent to third-party servers, ensuring your intellectual property remains private.

Try Atlas in your terminal

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

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

Atlas for Erlang in 2026

Atlas is a terminal-native AI coding agent for Erlang/OTP in 2026. Run it in an app with a rebar.config, map supervisors and gen_server modules, review every diff.

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

In 2026, Erlang developers use Atlas to write unit tests for untested modules, leveraging `rebar3 eunit` and `erlfmt` to match existing project conventions and ensure code quality.

Plan a Multi-File Change Before Editing in Erlang with Atlas in 2026

In 2026, Erlang developers use Atlas to plan and review complex multi-file changes, ensuring design approval before modifying a single line of code or running rebar3. Securely design Erlang system updates.

Refactor a Legacy Erlang Module with Atlas in 2026

Safely refactor Erlang modules in 2026 using Atlas, the terminal-native AI coding agent. Map callsites, verify behavior with rebar3 eunit, and apply changes with precision, all while maintaining Erlang code style with

Self-review Your Working Diff Before Committing in Erlang with Atlas in 2026

Erlang developers in 2026 use Atlas to self-review uncommitted diffs, catching mistakes before CI. Leverage rebar3, erlfmt, and eunit with AI assistance.

Locate Erlang Behavior Implementations with Atlas in 2026

In 2026, Erlang developers use Atlas to quickly find where a behavior is implemented, leveraging semantic search, grep, and LSP tools across rebar3 projects.

Run Atlas Headless in CI in Erlang with Atlas in 2026

Automate Erlang development in CI/CD with Atlas. Run Atlas headless, integrate with rebar3 and erlfmt, and get machine-readable output for Erlang/OTP projects in 2026.

Browse this resource hub