# Locate where a behavior is implemented in Remix with Atlas in 2026 > Atlas helps Remix developers find the exact file and symbol responsible for a behavior, even when only the software's function is known. In 2026, Remix developers can efficiently locate where a behavior is implemented by describing it to Atlas, which then leverages `codebase_search`, `grep`, and the `lsp` tool to pinpoint the exact file and symbol. This approach works even when you only know what the software does, not what the code is called, integrating direct with your existing `pnpm` and `vitest` workflows within a Remix or React Router 7 application. ## Key takeaways - Atlas uses hybrid semantic and keyword search to locate Remix behavior. - `grep` confirms semantic hits against actual text patterns in Remix `routes/`. - The `lsp` tool navigates Remix loader, action, and component call graphs. - Atlas operates with permission-gated tools and requires approval for all file edits. - Atlas integrates with Remix's `pnpm`, `vitest`, and `prettier` workflows. - Atlas understands Remix's nested routes, loaders, actions, and `ErrorBoundary` components. ## How Atlas Locates Remix Behavior with Semantic Search Atlas helps Remix developers in 2026 pinpoint behavior by describing it to `codebase_search`. This tool uses a hybrid semantic and keyword retrieval, indexing code by AST declarations with tree-sitter, not blind line windows, ensuring precise results even if your description doesn't match exact code terms. It's a powerful first step in understanding complex Remix data flows. When you need to find the implementation of a specific behavior in your Remix application, but you don't know the exact function or variable names, Atlas's `codebase_search` tool is your starting point. Unlike traditional keyword searches, `codebase_search` understands the meaning behind your query. It builds its code index using AST declarations via tree-sitter, allowing it to grasp the structure and context of your Remix loaders, actions, and nested routes. This means you can describe a behavior like 'the logic for submitting the user registration form' or 'where the product details are fetched' without needing to guess specific code identifiers. Atlas can even build its code index with local Ollama embeddings, ensuring your proprietary Remix code remains off third-party servers. This semantic understanding is crucial for navigating large Remix codebases where data flow is often managed through declarative patterns rather than explicit client-side state. ## Confirming Remix Code Locations with `grep` and File Paths After an initial semantic search, Atlas confirms potential Remix code locations using its `grep` tool, which runs `ripgrep` with real regex, plus include and path filters. This step is crucial for verifying semantic hits against actual text patterns within your `routes/` directory or `routes.ts` file, ensuring 100% accuracy. It's the second of three complementary approaches Atlas uses. Once `codebase_search` provides candidate declarations, Atlas's `grep` tool offers a complementary, precise method for confirmation. This tool leverages `ripgrep` under the hood, allowing you to use full regular expressions and specify include/path filters. For a Remix project, this is invaluable for narrowing down results to specific areas like `app/routes/**/*.ts` or `app/components/**/*.tsx`. For instance, if `codebase_search` suggests a file related to 'user authentication,' you might then use `grep` to search for a specific string like `authenticateUser` or a pattern like `loader: async \(.*?\) =>` within the suggested Remix route modules. This combination ensures that you not only find semantically relevant code but also confirm its exact textual presence and context within your `routes.ts` or `routes/` directory structure, which is fundamental to Remix's file-system based routing. ## Navigating Remix Symbol Graphs with the `lsp` Tool Once a candidate file is identified, Atlas's `lsp` tool becomes invaluable for Remix developers in 2026, allowing you to explore the symbol graph. You can use `findReferences` to see every callsite of a loader or action, or `workspaceSymbol` to jump directly to a declaration by name, providing a 360-degree view of code flow within your Remix application. This is the third pillar of Atlas's retrieval strategy. With a promising file and symbol identified, the `lsp` (Language Server Protocol) tool in Atlas provides deep insights into your Remix application's structure. For a Remix developer, understanding how loaders, actions, and nested routes interact is paramount. The `lsp` tool's `findReferences` operation can show you every place a specific loader function, action, or component is called or referenced throughout your codebase. This is particularly useful for tracing data flow in Remix, where a loader in a parent route might provide data to child routes. Conversely, if you know the name of a symbol (e.g., `loginAction` or `productLoader`) but not its exact location, `workspaceSymbol` allows you to jump directly to its declaration. This capability is essential for quickly understanding the full lifecycle and dependencies of any behavior within your Remix project, especially when dealing with React Router 7's advanced routing features. ## Reviewing and Approving Atlas's Remix Code Findings and Edits Atlas prioritizes safety and transparency in 2026, ensuring every step of locating Remix behavior is permission-gated. Before any tool runs, Atlas drafts a read-only plan, asks for approval, and computes a unified diff for any proposed file edits, which you must approve before writing, providing full control over your `vite.config.ts` and other project files. This robust review process is a core Atlas feature. Atlas is designed with a strong emphasis on developer control and safety. When you're using Atlas to locate behavior in your Remix project, every tool call is permission-gated against allow, ask, and deny rules. This means Atlas will never execute a command without your explicit consent. Before switching to a build agent that can make changes, Atlas drafts a plan in a read-only plan agent and presents it for your review. If Atlas proposes any edits to your Remix files - perhaps to refactor a loader or update an action - it computes a unified diff for every single file change. This diff is then surfaced for your approval, allowing you to inspect every line of code before it's written to your `routes/` directory, `vite.config.ts`, or any other part of your project. Atlas also reads `git` branches, status, and diffs, and can stage and create commits on your behalf, ensuring a fully integrated and auditable workflow for your Remix development. ## Steps 1. Start Atlas in your Remix project, ensuring it can read your `routes.ts` or `routes/` directory and `vite.config.ts`. 2. Describe the behavior you want to locate to Atlas using `codebase_search`. For example: `atlas codebase_search "where is the logic for handling user login form submissions?"` 3. Review the semantic search results and confirm potential code locations with Atlas's `grep` tool, specifying Remix-relevant paths. Example: `atlas grep "loginAction" --include "app/routes/**/*.ts"` 4. Open the most promising candidate file with the `read` tool. If the path is incorrect, Atlas will provide a 'Did you mean' list. Example: `atlas read "app/routes/auth/login.tsx"` 5. Use the `lsp` tool's `findReferences` operation to trace all calls to a specific Remix loader or action within that file. Example: `atlas lsp findReferences "loginAction"` 6. Alternatively, use `lsp workspaceSymbol` to jump directly to a declaration if you know its name. Example: `atlas lsp workspaceSymbol "authenticateUser"` 7. Summarize the identified call path and implementation details back to yourself with concrete file and line references using Atlas's summarization capabilities. 8. Approve any proposed changes or refactorings Atlas might suggest, reviewing the unified diff before Atlas writes to your Remix codebase. ## FAQ ### How does Atlas find Remix code without exact keywords? Atlas uses `codebase_search` with hybrid semantic and keyword retrieval, indexing Remix code by AST declarations using tree-sitter. This allows it to understand the meaning and context of your Remix loaders and actions, even if your description doesn't match literal text in the source. ### Can Atlas find references for Remix loaders and actions? Yes, Atlas's `lsp` tool is specifically designed for this. You can use its `findReferences` operation to locate every callsite for Remix loaders and actions, providing a comprehensive view of how data flows through your nested routes and components. ### What Remix files and structures does Atlas understand? Atlas is built to understand Remix and React Router 7 applications. It reads `routes.ts` or `routes/` directories, `vite.config.ts`, loader and action exports, nested route hierarchies, and `ErrorBoundary` components, allowing it to navigate your project's unique structure. ### How does Atlas ensure I approve changes to my Remix project? Atlas operates with a read-only plan agent and asks for explicit permission before running any tools that could modify files. For any proposed edits, it computes a unified diff and surfaces it for your approval, ensuring you have full control before Atlas writes to your Remix codebase. ### Does Atlas integrate with Remix's `vitest` or `prettier`? Yes, Atlas integrates direct with your Remix toolchain. It can add `Form` actions with progressive enhancement and cover them with `vitest`, and it can run `prettier` across touched route modules after making edits, maintaining your project's formatting standards. ### What if Atlas suggests a wrong file path in Remix? Atlas's `read` tool is designed to fail loudly if a path is incorrect. It will return 'File not found' along with a 'Did you mean' list, preventing you from wasting time on bad paths and guiding you to the correct Remix file location. ### Can Atlas help me understand data flow in complex Remix nested routes? Absolutely. By combining `codebase_search` for initial discovery, `grep` for textual confirmation, and the `lsp` tool's `findReferences` for tracing loader and action calls, Atlas provides a powerful workflow to understand data flow across even the most complex Remix nested routes. --- Canonical HTML: https://runatlas.sh/resources/stacks/locate-where-a-behavior-is-implemented-in-remix Source of truth: aeo_pages row `/resources/stacks/locate-where-a-behavior-is-implemented-in-remix` (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.