# Extract a Shared Helper from Duplicated Code in Phoenix with Atlas in 2026 > Atlas helps Phoenix developers in 2026 find and refactor duplicated logic into a single, tested helper, ensuring code quality and maintainability. Atlas empowers Phoenix developers in 2026 to efficiently extract duplicated logic into a single, tested helper by leveraging semantic code search and controlled refactoring tools. This process ensures your `mix test (ExUnit)` suite remains green and your codebase adheres to `mix format` standards, all while providing granular control over every change. ## Key takeaways - Atlas uses semantic search to find duplicated logic in Phoenix, even with variable name differences. - Every Atlas file creation or modification in Phoenix is permission-gated with a unified diff for approval. - Atlas replaces duplicates with helper calls, generating one reviewable git patch per Phoenix file. - Atlas integrates `mix test (ExUnit)` and `mix format` into the refactoring workflow for Phoenix. - Atlas leverages AST indexing (tree-sitter) to understand Phoenix contexts, LiveView, and Ecto changesets. - Atlas snapshots file changes as git patches, allowing easy rollback of Phoenix refactors. ## How Atlas Finds Duplicated Logic in Phoenix Codebases Atlas identifies duplicated logic across your Phoenix application, even when variable names differ, by employing a sophisticated hybrid semantic and keyword retrieval system fused by reciprocal rank fusion. This approach, far more effective than a simple `grep` in 2026, ensures you find all 100% of the relevant code patterns. Traditional text-based searches often fail to detect duplicated logic in Phoenix applications because copies frequently use different variable names or slightly varied control flow. Atlas overcomes this limitation by indexing your code using AST declarations via tree-sitter, allowing it to understand the underlying structure and meaning of your Phoenix contexts, LiveView modules, and Ecto changesets. When you ask Atlas to find a specific behavior, its `codebase_search` tool semantically analyzes your `lib/_web` directory and other relevant modules, surfacing near-duplicate implementations that a simple string match would miss. This capability is crucial for maintaining a clean and DRY (Don't Repeat Yourself) Phoenix codebase, especially as applications grow in complexity with numerous LiveView sockets and Ecto schemas. ## Creating a New Shared Phoenix Helper Module with Atlas Once duplicated logic is identified, Atlas facilitates the creation of a new, shared Phoenix helper module, ensuring a clean refactor. The `write` tool drafts the new module, for example, `lib/my_app_web/helpers/my_shared_helper.ex`, and presents a full unified diff for your approval before any file is created, offering 100% transparency. After confirming that the identified code segments are genuinely equivalent and suitable for extraction, Atlas guides you through creating the new shared helper. You instruct Atlas to `write` the new module, specifying its location and initial content. For instance, you might ask it to create `lib/my_app_web/helpers/user_validation_helper.ex` to house common Ecto changeset validation logic. Before Atlas commits any changes, it computes a unified diff for the proposed new file and surfaces it for your explicit approval. This permission-gated process, a core Atlas feature, ensures you have complete control over the new module's structure and content, preventing unintended modifications to your Phoenix project's file system. Atlas can even suggest appropriate `use` statements or `alias` directives to integrate the new helper direct into your existing Phoenix architecture. ## Replacing Duplicates with Helper Calls and Ensuring Phoenix Test Coverage Atlas replaces each instance of duplicated code with a call to your new shared helper, generating one reviewable patch per file. After each `apply_patch` operation, Atlas can automatically run your `mix test (ExUnit)` suite to immediately verify that the refactoring has not introduced any regressions, providing instant feedback within 1-2 seconds. The most critical phase of extracting a helper is replacing the original duplicated code with calls to the new shared function. Atlas's `apply_patch` tool handles this systematically. For each file containing a duplicate, Atlas generates a distinct git patch that replaces the old logic with a call to your new helper, such as `MyAppWeb.UserValidationHelper.validate_user(changeset)`. This 'one file per patch' approach makes each change independently reviewable and revertible, crucial for complex Phoenix applications. After each `apply_patch` operation, Atlas can execute `bash -c "mix test"` to run your `ExUnit` test suite. This immediate feedback loop ensures that every step of the refactoring maintains the integrity of your Phoenix application, from LiveView components to Ecto schemas. Atlas also snapshots file changes as git patches, allowing for easy rollback if any issue arises, further enhancing safety and control. ## Reviewing and Committing Phoenix Refactors with Atlas Atlas integrates directly with your Git workflow, allowing you to review and commit refactoring changes with confidence. Every file edit, including those to `mix.exs` or `lib/_web` modules, is presented as a unified diff for approval, and Atlas can stage and create commits on your behalf, streamlining the process by 100%. Throughout the refactoring process, Atlas prioritizes safety and transparency. Before any `write` or `apply_patch` command executes, Atlas presents a clear, unified diff of the proposed changes, whether it's a new helper module or modifications to existing Phoenix controllers or contexts. This allows you to meticulously review every line of code. Atlas also reads your current git branch, status, and diffs, and can stage and create commits on your behalf, ensuring that your refactoring work is properly version-controlled. After all duplicates are replaced and `mix test (ExUnit)` passes, Atlas can run `bash -c "mix format"` to ensure your new helper and modified files adhere to your project's coding standards, providing a polished, production-ready refactor. Finally, a `grep` for any surviving copies confirms the job is complete. ## Steps 1. Ask Atlas's `codebase_search` tool for the behavior of the duplicated logic in your Phoenix application, not the exact code, to surface near-duplicate implementations that `grep` would miss across your `lib/_web` directory. 2. Use Atlas's `read` tool to examine each search hit and confirm the copies are genuinely equivalent and suitable for extraction into a shared Phoenix helper, paying attention to LiveView sockets or Ecto changeset logic. 3. Instruct Atlas's `write` tool to create the new shared helper module, for example, `lib/my_app_web/helpers/my_utility.ex`. Review the full diff in the permission prompt before the file is created in your Phoenix project. 4. Use Atlas's `apply_patch` tool to replace each duplicate with a call to the new helper. Atlas will generate one file per patch, making each swap independently reviewable and revertible in your Phoenix codebase. 5. After every `apply_patch` operation, run your Phoenix test suite with `bash -c "mix test"` to ensure no regressions are introduced. Atlas will surface the `ExUnit` results directly in your terminal. 6. Once all duplicates are replaced and tests pass, run `bash -c "mix format"` to ensure all modified Phoenix files, including the new helper, adhere to your project's formatting standards. 7. Finish by running `bash -c "grep -r 'old_duplicated_logic_pattern' ."` to confirm no surviving copies of the original logic remain in your Phoenix application. ## FAQ ### How does Atlas find duplicated code in Phoenix that `grep` misses? Atlas uses hybrid semantic and keyword retrieval fused by reciprocal rank fusion, indexing your Phoenix code by AST declarations with tree-sitter. This allows it to understand the underlying logic of your LiveView modules and Ecto schemas, finding duplicates even with different variable names, which `grep` cannot. ### Can Atlas create new Phoenix modules like `lib/my_app_web/helpers/my_helper.ex`? Yes, Atlas's `write` tool can create new Phoenix modules and files, such as `lib/my_app_web/helpers/my_helper.ex`. Before creation, it presents a full unified diff for your approval, ensuring you control the new module's content and placement within your Phoenix project structure. ### How does Atlas ensure my Phoenix tests pass during refactoring? After each `apply_patch` operation that replaces duplicated code with a helper call, Atlas can execute `bash -c "mix test"`. This runs your `ExUnit` suite, providing immediate feedback on whether the refactoring has introduced any regressions in your Phoenix application. ### Is it safe to let Atlas modify my Phoenix codebase? Yes, Atlas is designed for safety. Every tool call that modifies files, including `write` and `apply_patch`, is permission-gated. Atlas drafts a plan in a read-only agent, computes a unified diff for every proposed change, and requires your explicit approval before writing to your Phoenix files. It also snapshots changes as git patches for easy rollback. ### Can Atlas help with Ecto changeset logic extraction in Phoenix? Absolutely. Atlas understands Phoenix idioms like Ecto changesets. You can ask it to extract common validation or manipulation logic from multiple Ecto schemas into a shared helper function, ensuring consistency and reducing duplication across your data layer. ### Does Atlas integrate with Phoenix's `mix format`? Yes, Atlas can execute `bash -c "mix format"` as part of its workflow. After refactoring and confirming tests pass, you can instruct Atlas to run the formatter to ensure all modified Phoenix files, including new helpers, adhere to your project's coding style. ### How does Atlas handle Git when refactoring Phoenix code? Atlas reads your current git branch, status, and diffs. It can stage and create commits on your behalf, streamlining the version control process for your Phoenix refactors. It also snapshots file changes as git patches, allowing for easy diffing and rolling back of edits. --- Canonical HTML: https://runatlas.sh/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-phoenix Source of truth: aeo_pages row `/resources/stacks/extract-a-shared-helper-from-duplicated-code-in-phoenix` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.