To plan a multi-file change in Elixir before editing, Atlas ships a plan agent whose description is literally Plan mode. Disallows all edit tools. Its permission set denies edit for every path except the plan markdown, so research across your mix.exs, your contexts, and your supervision tree cannot accidentally turn into an edit. When the plan is ready, the plan_exit tool asks whether to switch to the build agent and start implementing, and only then does anything under lib/ change.
How do I plan an Elixir refactor without an AI agent editing my code?
Atlas plans an Elixir change in its plan agent, whose description is literally Plan mode. Disallows all edit tools. In 2026 the permission set denies edit for "*" and allows it only under .atlas/plans/*.md, so a research pass over lib/ and mix.exs cannot rewrite a GenServer by accident.
A change that touches a context, its schema, the GenServer that consumes it, and the ExUnit tests that cover all three is exactly the change you want designed before it is typed. Elixir makes the blast radius wide by default: a modified function head ripples through pattern matches, a changed struct ripples through every %Mod{} match in the app. Plan mode is a permission boundary rather than a polite request, which is why the design phase in Atlas is enforced instead of merely encouraged. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs.
What can Atlas actually do in Elixir plan mode?
Atlas in plan mode can research an Elixir project with the 4 tools that stay allowed: codebase_search, grep, read, and the lsp tool. Reading lib/my_app/accounts.ex, tracing a GenServer through its supervision tree, and grepping for every caller of a context function all remain available while edits are denied.
Plan mode is not a reduced-capability mode for understanding, only for writing. codebase_search queries the semantic index for behavior, so a plain-language question about how a job is retried finds the right module even when the module name says nothing about retries. grep confirms it against the literal source. The lsp tool walks the symbol graph across lib/ and test/. What the plan agent cannot do is call edit, which is the entire point: the same session that reads your Mix and Hex dependency tree cannot quietly start changing it.
Where does Atlas write the Elixir plan, and why only there?
Atlas writes the Elixir plan under .atlas/plans/*.md, and in 2026 that is the only path plan mode can write: the permission set denies edit for "*" and allows it only there. Your lib/, test/, and mix.exs stay unreachable from the plan agent by construction.
A single writable path makes the boundary auditable. The plan markdown holds the design: which contexts change, which GenServer callbacks gain a clause, which ExUnit tests must be added under test/, and in what order the steps land. Because the file lives in the repository, the plan is reviewable by a teammate the same way code is, and Atlas reads git branches, status, and diffs so the plan and the tree it describes stay visible together. Nothing in lib/ has moved at this point, so the cost of rejecting the plan is zero.
How do I switch from planning to implementing in Atlas?
Atlas hands off with the plan_exit tool, which asks: Plan at <path> is complete. Would you like to switch to the build agent and start implementing? The question has exactly 2 answers. Yes moves the Elixir work to the build agent. No raises Question.RejectedError and keeps you refining the plan.
The handoff is an explicit question rather than a silent mode change, which means an Elixir plan never turns into an implementation you did not authorize. Answering No is a first-class outcome: Question.RejectedError keeps the session in plan mode so the design can be tightened, more of lib/ can be read, and another pass at the ordering can be made. Answering Yes moves to the build agent, where edits become possible and Atlas computes a unified diff for every file edit and surfaces it for approval before writing.
What happens after the Elixir build agent starts implementing the plan?
Once the Atlas build agent takes over an Elixir plan in 2026, each step lands as a reviewed unified diff, and ExUnit via mix test proves it before the next step starts. Running mix format keeps the diff free of style noise, and Atlas snapshots file changes as git patches so any step can be rolled back.
The plan is the contract the build agent works against, so a multi-file Elixir change lands in the order the plan set: schema first, then the context, then the GenServer, then the tests. Running ExUnit via mix test after each step means a failing pattern match is attributed to the step that introduced it rather than discovered at the end of a ten file diff. Mix and Hex resolve the deps the tests run against, and mix format normalizes the touched files so the final review shows the design, not the whitespace.
Step by step
- 01Run atlas in an Elixir project with a mix.exs and let Atlas read your supervision tree, contexts, and deps.
- 02Switch to the plan agent; its permissions deny edit for "*" and allow it only under .atlas/plans/*.md.
- 03Research with codebase_search, grep, read, and the lsp tool, all of which stay allowed in plan mode, to map which contexts, GenServers, and ExUnit tests the change touches.
- 04Write the plan into the allowed plan markdown path, which is the one place plan mode can write, listing the steps in the order they should land.
- 05Call plan_exit: it asks Plan at <path> is complete. Would you like to switch to the build agent and start implementing?
- 06Answer Yes to hand off to the build agent; answering No raises Question.RejectedError and keeps you refining the plan.
- 07In the build agent, land one step at a time and run ExUnit via mix test after each one, with Mix and Hex resolving the deps.
- 08Run mix format over the touched files in lib/ and test/ before review.
Frequently asked questions
- how do i stop an AI agent from editing my elixir code while it researches
- Use Atlas's plan agent. Its permission set denies edit for "*" and allows it only under .atlas/plans/*.md, so a research pass over lib/ and mix.exs cannot modify a context or a GenServer.
- what is plan mode in atlas
- The plan agent's description is literally Plan mode. Disallows all edit tools. Research tools such as codebase_search, grep, read, and the lsp tool stay available, but edits are denied for every path except the plan markdown.
- how do i plan a multi-file refactor in an elixir umbrella project
- In plan mode, map the change with codebase_search and the lsp tool across your contexts and supervision tree, then write the ordered steps into the allowed plan markdown path before any edit is possible.
- how do i switch from planning to building in atlas
- Call plan_exit. It asks Plan at <path> is complete. Would you like to switch to the build agent and start implementing? Yes hands off to the build agent, and No raises Question.RejectedError so you keep refining.
- what does atlas need to work on an elixir project
- Run atlas in a project with a mix.exs. Atlas reads your supervision tree, contexts, and deps, and can add ExUnit tests or restructure a GenServer with the diff shown for review.
- does atlas run mix test after implementing a plan
- In the build agent, Atlas runs ExUnit via mix test through bash after each step of the plan, so a failing pattern match is attributed to the step that introduced it rather than found at the end.
- can i reject an atlas plan without losing the work
- Yes. Answering No to plan_exit raises Question.RejectedError and keeps the session in plan mode with the plan markdown intact, so the Elixir design can be refined rather than discarded.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Plan a Multi-File Change Before Editing with Atlas in 2026
How to plan a multi-file change with Atlas in 2026: the plan agent denies all edit tools, you research with codebase_search and lsp, then plan_exit hands off.
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.
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.
Locate Where a Behavior Is Implemented in Elixir With Atlas (2026)
How to locate where a behavior is implemented in an Elixir codebase with Atlas in 2026: codebase_search for meaning, grep for text, and the lsp tool for symbols.
Onboard to an unfamiliar codebase in Elixir with Atlas (2026)
How to onboard to an unfamiliar Elixir codebase in 2026 with Atlas: codebase_search over the semantic index, glob across mix.exs projects, and ExUnit via mix test.
Audit an Elixir Repo with Parallel Subagents in 2026 using Atlas
Sweep your Elixir repository for specific problems without blowing your context window. Atlas uses parallel subagents, ExUnit, Mix, and Hex to audit large Elixir codebases efficiently.
Automate GitHub Issue and Pull Request Triage in Elixir with Atlas in 2026
Automate GitHub issue and pull request triage in Elixir projects using Atlas. Configure workflows to safely respond to events, ensuring only trusted users trigger actions and reviewing all changes.
Document an Elixir Module with a README in 2026 using Atlas
Generate accurate, up-to-date README documentation for your Elixir modules with Atlas. Leverage Mix, Hex, and ExUnit for verified, traceable docs.