# Onboard to an Unfamiliar Expo Codebase in 2026 with Atlas > Atlas helps Expo developers in 2026 quickly understand unfamiliar codebases by leveraging semantic search and integrating with `expo-router` and config plugins. Atlas helps Expo developers in 2026 rapidly build a working mental model of unfamiliar codebases by starting from meaning, not filenames, and integrating directly with the Expo toolchain. It uses semantic search to pinpoint relevant code, understands `expo-router` routes and config plugins, and safely interacts with tools like `npx expo install`, `jest-expo`, and `prettier` through permission-gated operations. ## Key takeaways - Atlas uses semantic search to quickly pinpoint relevant code in Expo projects. - It understands `expo-router` routes and config plugins for native capabilities. - Atlas integrates with `npx expo install`, `jest-expo`, and `prettier` for Expo-specific tasks. - All Atlas actions are permission-gated, requiring explicit user approval for changes. - Unified diffs are presented for every file edit, ensuring full control over modifications. ## How does Atlas understand an Expo project's structure? Atlas builds a foundational understanding of an Expo project's structure in 2026 by indexing code with AST declarations and analyzing key configuration files. It starts by reading `app.json` or `app.config.ts` and the `app/` directory, then uses `glob` to map the top-level package layout, providing a clear overview in just a few seconds. When you run Atlas in an Expo project, it first reads critical configuration files like `app.json` or `app.config.ts` to understand the project's core setup. It also scans the `app/` directory to identify `expo-router` file routes, which are central to navigation in modern Expo applications. Atlas indexes the codebase using AST declarations via tree-sitter, allowing it to understand code structure beyond simple line windows. This semantic index is then queried using the `codebase_search` tool, which fuses semantic and keyword retrieval to return ranked snippets with file paths relevant to your plain-language questions. For a high-level overview, the `glob` tool can be run on top-level directories, revealing the package layout and naming conventions without requiring you to open a single file. ## How does Atlas navigate Expo-specific features like config plugins and `expo-router`? Atlas is designed to navigate Expo-specific features like `expo-router` routes and config plugins, which are crucial for native capabilities in 2026. It reads your `expo-router` definitions and the plugins array in your `app.json` or `app.config.ts`, allowing it to propose changes or explain existing configurations without manual file edits, ensuring prebuild remains reproducible. Atlas understands the unique aspects of Expo development. It can read your `expo-router` routes directly from the `app/` directory, providing insights into the application's navigation flow. For native capabilities, Atlas is aware of config plugins, which replace hand-managed native projects. Instead of manually editing `ios/` and `android/` directories, you can ask Atlas to add a native capability, and it will propose the necessary config plugin modifications. This approach ensures that your project's `prebuild` process remains reproducible and consistent. Atlas also reads `eas.json` build profiles, giving it context on how your application is built and deployed across different environments, further enhancing its ability to assist with complex Expo workflows. ## How does Atlas interact with Expo's package management and testing tools? Atlas interacts directly with Expo's standard package management and testing tools, ensuring consistency and safety in 2026 development workflows. It installs packages using `npx expo install` to maintain SDK version pinning and runs tests with `jest-expo`, all behind explicit permission prompts, providing a secure and controlled environment for code changes. Atlas integrates direct with the Expo toolchain. When new packages are required, Atlas uses `npx expo install`, ensuring that dependencies are installed with versions pinned to your current SDK release, which is critical for maintaining project stability. For testing, Atlas can run your project's tests using `jest-expo`. Every tool call, including package installations and test runs, is permission-gated. Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent to execute commands. This means you explicitly grant permission before Atlas installs packages or runs `jest-expo`, giving you full control over your environment. After any code modifications, Atlas can also run `prettier` to format the diff, ensuring code style consistency before you approve the changes. ## What safety and review mechanisms does Atlas provide for Expo code changes? Atlas provides robust safety and review mechanisms for Expo code changes, ensuring developers maintain full control over their projects in 2026. Every Atlas tool call is permission-gated against allow, ask, and deny rules, and it computes a unified diff for every file edit, surfacing it for approval before writing, preventing unintended modifications. Safety is paramount when Atlas makes changes to an Expo codebase. Before any tool runs, Atlas checks its permission-gated rules, which can be set to `allow`, `ask`, or `deny`. This means you are always in control of what Atlas can execute. When Atlas proposes code modifications, it first drafts a plan in a read-only agent, which you review. Only after your approval does it switch to a build agent to implement the changes. Crucially, for every file edit, Atlas computes a unified diff and presents it to you for explicit approval. This allows you to review every line change before it is written to disk. Atlas also snapshots file changes as git patches, so edits can be easily diffed and rolled back if needed, providing an additional layer of security and auditability for your Expo project. ## Steps 1. Start Atlas in your Expo project, ensuring `app.json` or `app.config.ts` and the `app/` directory are present for Atlas to index. 2. Ask Atlas a plain-language question using `codebase_search` about a concept, like 'how are requests authenticated in this Expo app?', to get ranked code snippets and file paths. 3. Run `glob` on the top-level directories to quickly visualize the Expo project's package layout and naming conventions, understanding the `app/` structure and `eas.json` profiles. 4. Read the two or three highest-ranked files from `codebase_search` using the `read` tool, then follow imports with the `lsp` tool's `goToDefinition` operation to trace dependencies within the Expo codebase. 5. Delegate wider exploration tasks to the `explore` subagent using the `task` tool, for example, 'explore all `expo-router` routes and their associated components', knowing it's read-only and permissioned for safe sweeps. 6. Record your findings and any remaining open questions as a `todowrite` list, ensuring your mental model evolves and persists across Atlas sessions for your Expo project. ## FAQ ### How does Atlas handle `expo-router` navigation in an unfamiliar codebase? Atlas reads your `app/` directory to understand `expo-router` file routes. You can ask it questions about navigation flow or use `lsp` to trace route definitions, helping you quickly grasp the application's structure. ### Can Atlas help me understand config plugins without reading all the documentation? Yes, Atlas reads the plugins array in your `app.json` or `app.config.ts`. You can ask it to explain what a specific config plugin does or even propose adding a new native capability via a plugin, keeping your `prebuild` reproducible. ### Is it safe to let Atlas install packages with `npx expo install`? Absolutely. Atlas uses `npx expo install` to ensure SDK version pinning. Every tool call, including package installations, is permission-gated. Atlas will draft a plan and ask for your explicit approval before executing the command. ### How does Atlas ensure I don't accidentally break my Expo project? Atlas operates with a strong emphasis on safety. It drafts plans in a read-only agent, asks for approval before executing, and presents a unified diff for every proposed file change. You review and approve all modifications before they are written to disk. ### Can Atlas help me run `jest-expo` tests and format code? Yes, Atlas can run `jest-expo` tests on your behalf, behind a permission prompt. After making changes, it can also run `prettier` to format the resulting diff, ensuring your Expo codebase maintains consistent style. ### What if I need to explore a large Expo codebase without making changes? You can delegate wide sweeps to the `explore` subagent using the `task` tool. This subagent is defined with a deny-by-default permission set, allowing only read-only operations like `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`, ensuring no accidental modifications. --- Canonical HTML: https://runatlas.sh/resources/stacks/onboard-to-an-unfamiliar-codebase-in-expo Source of truth: aeo_pages row `/resources/stacks/onboard-to-an-unfamiliar-codebase-in-expo` (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.