Atlas is a terminal-native AI coding agent for Erlang/OTP systems built with rebar3, where supervision trees and hot code loading matter more than raw syntax. In 2026 you run atlas in an application with a rebar.config and a src/*.app.src, and Atlas maps your supervisor callbacks, gen_server modules, and release config in relx before proposing a change.
Why Erlang developers use Atlas
Erlang developers use Atlas in 2026 because OTP behavior lives in structure, not syntax. Atlas maps your supervisor callbacks, gen_server modules, and release config in relx, so it knows which process supervises which child and how each one restarts.
In Erlang the important relationships are not lexical. A gen_server is reached through a registered name rather than a function call. A child spec inside a supervisor init decides restart intensity and shutdown order. A release assembled by relx determines what actually ships to a node and in what order applications start. None of that is visible to a tool reading a .erl file as flat text. Atlas indexes code by AST declarations using tree-sitter, which is the only way multi-clause functions read correctly: a function whose meaning is spread across five clauses matching different message shapes is nonsense when a chunker slices it between the third clause and the fourth.
Starting Atlas in a rebar3 application
Setup for Erlang in 2026 takes one command: run atlas in a rebar3 application with a rebar.config and a src/*.app.src. Atlas is terminal-native, so it runs in the terminal where you already open a shell against a running node.
Atlas starts at the application root, finds the rebar.config and the src/*.app.src, and maps your supervisor callbacks, gen_server modules, and release config in relx. Reading the relx configuration is what tells Atlas which applications ship together, which is the difference between a suggestion that fits the release and one that quietly fails to boot. Erlang is heavily used in telecom and infrastructure where source cannot leave a private network, and Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers.
Adding handle_call clauses and Common Test suites
The daily Erlang loop in 2026 is concrete: ask Atlas to add a handle_call clause or a Common Test suite under test/, then approve the diff. Adding a handle_call clause looks like a two-line change and is emphatically not one.
The new clause must pattern match correctly against the clauses already there, return a reply tuple in the shape the caller expects, and avoid shadowing a later clause that already handles the message. Clause order is semantics in Erlang, so a clause inserted in the wrong position is a silent behavior change rather than an error the compiler will catch. A Common Test suite under test/ is the companion work, with init_per_suite and end_per_suite standing up the processes a test needs and tearing them down afterward. Both tasks reward an agent that has mapped the gen_server modules rather than skimmed one file.
Running rebar3 eunit and rebar3 ct behind a permission prompt
Atlas can run rebar3 eunit and rebar3 ct behind a permission prompt before it commits, and Atlas can run erlfmt on the touched modules so the diff matches project style. Every Atlas tool call is permission-gated against allow, ask, and deny rules.
The Erlang workflow gives Atlas a real feedback loop without giving it free rein. Because rebar3 eunit and rebar3 ct sit behind a permission prompt, a change is validated by the same runners CI uses, and every invocation is one you approved. Running erlfmt on the touched modules means the diff you read is about behavior rather than whitespace, which matters enormously when the change is a clause inserted into an existing function: reformatting noise around a clause boundary is precisely the noise that hides an ordering mistake.
Review and rollback for supervision changes
Atlas computes a unified diff for every file edit and surfaces it for approval before writing, and Atlas snapshots file changes as git patches, which is how an Erlang supervision change is rolled back in 2026. A bad child spec does not fail at compile time.
It fails at three in the morning, under load, when a restart intensity nobody thought about takes down the supervisor that was supposed to be protecting the system. A supervisor that gives up and terminates its own parent is a cascade, and the code that caused it compiled perfectly. Because the change was snapshotted as a git patch, backing it out is a single operation rather than an archaeology exercise against a live node. An Erlang change lands only after rebar3 ct is green and the diff has been read.
Getting started
- 01Run atlas in an application with a rebar.config and a src/*.app.src.
- 02Let Atlas map your supervisor callbacks, gen_server modules, and release config in relx.
- 03Ask Atlas to add a handle_call clause or a Common Test suite under test/, then approve the diff.
- 04Let Atlas run rebar3 eunit and rebar3 ct behind a permission prompt before it commits.
- 05Have Atlas run erlfmt on the touched modules so the diff matches project style.
- 06Check clause order in the diff, since a clause in the wrong position is a silent behavior change.
Frequently asked questions
- can an AI agent understand an Erlang supervision tree
- Atlas maps your supervisor callbacks, gen_server modules, and release config in relx, so it reasons about which process supervises which child rather than reading modules as flat text.
- can Atlas write Common Test suites for Erlang
- Yes. Ask Atlas to add a handle_call clause or a Common Test suite under test/, then approve the diff. Atlas can then run rebar3 eunit and rebar3 ct behind a permission prompt before it commits.
- does Atlas work with rebar3
- Yes. Run atlas in an application with a rebar.config and a src/*.app.src. Atlas can run rebar3 eunit and rebar3 ct behind a permission prompt before it commits.
- how do I keep an AI agent from running Erlang tests without asking
- Every Atlas tool call is permission-gated against allow, ask, and deny rules, so rebar3 eunit and rebar3 ct only execute when you allow them.
- will an AI agent reformat my Erlang modules
- Atlas can run erlfmt on the touched modules so the diff matches project style, which keeps the review focused on clause order and behavior rather than whitespace.
- how do I roll back an AI change to a gen_server
- Atlas snapshots file changes as git patches, which matters because a bad child spec fails under load rather than at compile time.
- can Atlas index Erlang code without sending it to a third party
- Yes. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which suits telecom and infrastructure codebases.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
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.
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.
Run the Erlang Test Suite and Triage Failures with Atlas in 2026
Erlang developers in 2026 use Atlas to efficiently triage rebar3 eunit test failures, transforming extensive red output into a prioritized list of distinct root causes for rapid resolution.
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.
Onboard to an unfamiliar codebase in Erlang with Atlas in 2026
Erlang developers in 2026 can use Atlas to quickly build a mental model of unfamiliar rebar3 projects. Understand supervision trees, gen_server modules, and application structure without reading every file, leveraging
Add a Regression Test for a Bug Fix in Erlang with Atlas in 2026
Lock in Erlang bug fixes with Atlas in 2026. Learn to write failing regression tests using rebar3 eunit, apply fixes, and confirm passes, all with Atlas's terminal-native AI agent.
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.
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