How does Atlas handle Phoenix LiveView components?

Atlas is designed to understand Phoenix LiveView modules, their lifecycle callbacks like `mount/3` and `handle_event/3`, and how they interact with LiveView sockets. It can semantically search for behaviors within LiveView and use `lsp` to navigate functions and references specific to your `lib/ _web/live` components.

Can Atlas find Ecto schema definitions and changesets?

Yes, Atlas can locate Ecto schema definitions, changesets, and context functions. Its semantic search understands terms like 'Ecto schema' or 'changeset validation,' and it can use `grep` to find specific patterns in your `lib/ / / .ex` files, then `lsp` to explore their declarations and usages.

What Phoenix-specific commands does Atlas use?

While Atlas itself is a terminal-native AI agent, it understands and respects Phoenix's native toolchain. It can prompt you to run `mix test (ExUnit)` for verification, suggests using `Hex (mix deps.get)` for dependencies, and can finish tasks with `mix format` for code consistency, all behind permission prompts.

Is my Phoenix code sent to a third-party server when using Atlas?

No, Atlas can build its code index with local Ollama embeddings, keeping your Phoenix codebase entirely off third-party servers. This ensures your proprietary code remains secure and private within your local development environment.

How does Atlas ensure I approve changes to my Phoenix project?

Atlas operates with a read-only plan agent initially. Any proposed actions that would modify your Phoenix project, such as generating an Ecto migration or adding LiveViewTest cases, are presented as a unified diff for your explicit approval before Atlas writes any changes. It also snapshots file changes as git patches for easy rollback.

Can Atlas help me understand Phoenix router pipelines?

Absolutely. Atlas reads your router pipelines defined in `lib/ _web/router.ex` and can help you locate where specific plugs or behaviors are implemented within those pipelines. You can describe a routing behavior, and Atlas will use its tools to pinpoint the relevant code in your Phoenix router.

What if I only know a vague description of a Phoenix feature?

Atlas excels in this scenario. Its `codebase_search` tool uses hybrid semantic retrieval, meaning it can understand the *meaning* of your vague description, even if the exact words aren't in your Phoenix codebase. It then uses `grep` and `lsp` to narrow down to the precise file and symbol, guiding you from a high-level idea to concrete code.

Locate Phoenix Behavior with Atlas in 2026

Atlas helps Phoenix developers in 2026 pinpoint the exact file and symbol responsible for a behavior, even when only knowing what the software does, not what the code is called, by integrating semantic search, keyword matching, and symbol graph analysis directly within your terminal, understanding your `mix.exs` and `lib/<app>_web` structure, and respecting your `mix test (ExUnit)` and `mix format` workflows.

How does Atlas find Phoenix code when I only know what it does?

Atlas locates Phoenix code by attacking the problem from three angles simultaneously, ensuring comprehensive retrieval even in complex LiveView applications in 2026. It fuses semantic understanding, keyword matching, and symbol graph navigation to identify the exact file and symbol responsible for a behavior, even if your description doesn't match the code's literal text.

When you describe a behavior in your Phoenix application, Atlas first employs `codebase_search` to semantically understand your intent. This tool leverages hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, to find relevant code declarations. For a Phoenix developer, this means Atlas can understand concepts like 'updating a user's LiveView socket' or 'applying an Ecto changeset' without needing the exact function names. Atlas indexes your code by AST declarations using tree-sitter, providing a deeper understanding than blind line windows. It can build this index with local Ollama embeddings, keeping your proprietary Phoenix code off third-party servers. After semantic candidates are identified, Atlas uses `grep` for precise keyword matching, allowing you to confirm findings with real regex patterns and path filters within your `lib/<app>_web` directory. Finally, the `lsp` tool provides symbol graph capabilities, letting Atlas navigate declarations and references within your Phoenix project, ensuring the identified code is indeed the source of the behavior.

What Phoenix files and commands does Atlas use to locate behavior?

Atlas deeply integrates with the Phoenix ecosystem, reading your `mix.exs` and `lib/<app>_web` directory structure to understand your application's layout in 2026. It leverages standard Phoenix conventions to accurately locate behavior, using tools like `read` for file content, `grep` for pattern matching, and `lsp` for symbol navigation within your project.

Atlas operates within your Phoenix application by first reading your `mix.exs` file to understand project dependencies and structure. It then focuses on the `lib/<app>_web` directory, which is central to Phoenix applications, to identify key components like router pipelines, LiveView modules, contexts, and Ecto schemas with their changesets. When locating behavior, Atlas uses the `read` tool to open and display the content of candidate files, such as `lib/my_app_web/live/user_live.ex` or `lib/my_app/accounts/user.ex`. If a candidate file is a wrong guess, `read` fails loudly with a 'File not found' message and a 'Did you mean' list, preventing wasted effort. The `grep` tool is then used with actual commands like `grep "handle_event" lib/my_app_web/live/` to search for specific patterns within these Phoenix-specific paths. For navigating the code's structure, the `lsp` tool is invaluable, offering operations like `findReferences` to see every callsite of a Phoenix function or `workspaceSymbol` to jump directly to a declaration by name, such as `MyApp.Accounts.create_user/1`.

How does Atlas ensure accuracy and safety when locating Phoenix code?

Atlas prioritizes accuracy and safety throughout the code location process for Phoenix developers in 2026, employing a multi-layered approach to permissions and review. Every Atlas tool call is permission-gated, and all proposed changes are presented as unified diffs for explicit approval, ensuring you maintain full control over your codebase.

Atlas ensures accuracy by combining its three retrieval methods: semantic search, keyword search, and symbol graph navigation. This triangulation reduces false positives and helps pinpoint the exact code. For safety, Atlas operates with a robust permission model. Every tool call, whether it's `grep` searching your `lib/<app>_web` directory or `lsp` querying your symbol graph, is permission-gated against allow, ask, and deny rules before it runs. Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent that can interact with your files. If Atlas were to propose any edits, it computes a unified diff for every file change and surfaces it for your approval before writing, allowing you to review the exact modifications. Furthermore, Atlas snapshots file changes as git patches, so any edits can be easily diffed and rolled back, providing a safety net for your Phoenix project. This meticulous approach ensures that you, the Phoenix developer, are always in control and fully aware of Atlas's actions.

Can Atlas help me understand LiveView behavior in Phoenix?

Atlas is specifically designed to understand and work through the intricacies of Phoenix LiveView applications, making it an invaluable tool for developers in 2026. It can help locate the code responsible for UI interactions, data updates, and socket management within your LiveView modules, providing concrete file and line references.

Phoenix LiveView is a core strength for Atlas. Atlas is configured to read and understand your LiveView modules and the lifecycle of LiveView sockets. When you describe a behavior related to a LiveView component, such as 'where is the `handle_event` callback for submitting a form in `UserLive`?' or 'how is the `assigns` map updated after a database change?', Atlas can leverage its semantic understanding and `lsp` tool to pinpoint the relevant code. It can identify the specific `handle_event/3`, `handle_info/2`, or `mount/3` functions within your `lib/<app>_web/live` directory. Atlas can also help you trace how data flows into and out of LiveView components, understanding how Ecto changesets might trigger LiveView updates. This deep integration allows you to quickly jump to the declaration of a LiveView function using `lsp workspaceSymbol` or find all its usages with `lsp findReferences`, providing a clear picture of the LiveView's behavior and its interactions within your Phoenix application.

Step by step

01Initialize Atlas in your Phoenix project directory, ensuring it can read your `mix.exs` and `lib/<app>_web` structure.
02Describe the behavior you want to locate to Atlas using `codebase_search`, for example: "Find where a user's LiveView socket is updated after an Ecto changeset is applied in the `Accounts` context."
03Review the candidate declarations returned by `codebase_search`, paying close attention to file paths within your `lib/<app>_web` directory or `lib/<app>` contexts.
04Use `grep` with a specific regex to confirm text patterns in promising Phoenix files, such as `grep "socket |> assign" lib/my_app_web/live/user_live.ex` to confirm LiveView socket updates.
05Open the most promising Phoenix file with `read`, for instance: `read lib/my_app_web/live/user_live.ex`. Atlas will loudly indicate if the file is not found.
06Utilize the `lsp` tool to work through the code: use `lsp findReferences MyAppWeb.UserLive.handle_event/3` to see all calls to a specific LiveView event handler, or `lsp workspaceSymbol MyApp.Accounts.create_user` to jump to an Ecto context function's declaration.
07Summarize the call path and implementation details back to yourself or a colleague, including concrete file and line references from your Phoenix project.

Frequently asked questions

How does Atlas handle Phoenix LiveView components?: Atlas is designed to understand Phoenix LiveView modules, their lifecycle callbacks like `mount/3` and `handle_event/3`, and how they interact with LiveView sockets. It can semantically search for behaviors within LiveView and use `lsp` to navigate functions and references specific to your `lib/<app>_web/live` components.
Can Atlas find Ecto schema definitions and changesets?: Yes, Atlas can locate Ecto schema definitions, changesets, and context functions. Its semantic search understands terms like 'Ecto schema' or 'changeset validation,' and it can use `grep` to find specific patterns in your `lib/<app>/<context>/<schema>.ex` files, then `lsp` to explore their declarations and usages.
What Phoenix-specific commands does Atlas use?: While Atlas itself is a terminal-native AI agent, it understands and respects Phoenix's native toolchain. It can prompt you to run `mix test (ExUnit)` for verification, suggests using `Hex (mix deps.get)` for dependencies, and can finish tasks with `mix format` for code consistency, all behind permission prompts.
Is my Phoenix code sent to a third-party server when using Atlas?: No, Atlas can build its code index with local Ollama embeddings, keeping your Phoenix codebase entirely off third-party servers. This ensures your proprietary code remains secure and private within your local development environment.
How does Atlas ensure I approve changes to my Phoenix project?: Atlas operates with a read-only plan agent initially. Any proposed actions that would modify your Phoenix project, such as generating an Ecto migration or adding LiveViewTest cases, are presented as a unified diff for your explicit approval before Atlas writes any changes. It also snapshots file changes as git patches for easy rollback.
Can Atlas help me understand Phoenix router pipelines?: Absolutely. Atlas reads your router pipelines defined in `lib/<app>_web/router.ex` and can help you locate where specific plugs or behaviors are implemented within those pipelines. You can describe a routing behavior, and Atlas will use its tools to pinpoint the relevant code in your Phoenix router.
What if I only know a vague description of a Phoenix feature?: Atlas excels in this scenario. Its `codebase_search` tool uses hybrid semantic retrieval, meaning it can understand the *meaning* of your vague description, even if the exact words aren't in your Phoenix codebase. It then uses `grep` and `lsp` to narrow down to the precise file and symbol, guiding you from a high-level idea to concrete code.

Try Atlas in your terminal

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

Install Atlas

Related guides

Locate Where a Behavior Is Implemented with Atlas in 2026

How to locate where a behavior is implemented with Atlas in 2026: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph.

Atlas for Phoenix in 2026

Atlas is a terminal-native AI coding agent for Phoenix in 2026. It reads contexts, LiveView modules, and Ecto changesets, then runs mix test behind a prompt.

Review a pull request in Phoenix with Atlas in 2026

In 2026, Atlas helps Phoenix developers review pull requests by providing deep context, checking Ecto changesets, LiveView modules, and running mix test (ExUnit) with precision.

Extract a Shared Helper from Duplicated Code in Phoenix with Atlas in 2026

Refactor your Phoenix application in 2026 by extracting duplicated logic into a single, tested helper using Atlas. Find semantic duplicates, create new modules, and apply changes with full diff review.

Debug a single failing test in Phoenix with Atlas in 2026

Pinpoint and fix failing Phoenix tests with Atlas in 2026. Leverage `mix test (ExUnit)` and Atlas's AI to quickly diagnose issues in LiveView, Ecto, and contexts.

Self-review your working diff before committing in Phoenix with Atlas in 2026

Catch your own mistakes in Phoenix uncommitted diffs before review or CI. Atlas helps Phoenix developers self-review changes, run mix test (ExUnit), and apply mix format to ensure code quality in 2026.

Add a Regression Test for a Phoenix Bug Fix with Atlas in 2026

Lock in Phoenix bug fixes with Atlas by writing red-green regression tests. Use `mix test (ExUnit)` and `mix format` to ensure code quality and prevent future regressions in your Phoenix application.

Rename a symbol across your Phoenix repo in 2026 with Atlas

Rename functions, classes, or constants across your Phoenix codebase with Atlas in 2026. Leverage mix test (ExUnit) and mix format for safe, precise refactoring.

Browse this resource hub