How does Atlas ensure my Expo project's tests run correctly during a PR review?

Atlas uses the `bash` tool to execute `npx jest-expo`, your project's designated test runner, behind a permission prompt. It then reports the findings as a `todowrite` list, ensuring all tests pass before approval.

Can Atlas help me catch unformatted code in my Expo pull requests?

Yes, Atlas integrates with `prettier`. It can execute `npx prettier --write .` via the `bash` tool to automatically format changed files in your Expo project, ensuring consistent code style.

How does Atlas handle package installations for Expo dependencies?

Atlas can install packages using `npx expo install` through the `bash` tool. This action is permission-gated, meaning Atlas will ask for your approval before installing any new dependencies or updating existing ones, ensuring versions stay pinned to your SDK release.

What if a function signature changes in my Expo app and breaks other files not in the diff?

Atlas addresses this by using the `lsp` tool's `findReferences` operation. For every changed function signature, it checks all callers across your entire Expo project, identifying any files that need updates even if they weren't part of the original diff.

Does Atlas understand Expo-specific file structures like `app/` and `app.json`?

Yes, Atlas is designed to work within Expo projects. It can read your `expo-router` routes, the plugins array in your `app.json` or `app.config.ts`, and the `eas.json` build profiles, understanding the context of your project's structure.

How does Atlas prevent unintended changes to my Expo project?

Atlas employs a multi-stage safety workflow. It drafts a plan in a read-only agent, requires explicit permission for every tool call, and surfaces a unified diff for all proposed file edits for your approval before writing, ensuring you have 100% control.

Can Atlas help with Expo config plugins during a PR review?

Yes, Atlas can review changes related to config plugins. It can even be asked to add a native capability through a config plugin rather than editing `ios/` and `android/` by hand, ensuring your `prebuild` process remains reproducible and reviewable.

Review a Pull Request in Expo with Atlas in 2026

Reviewing an Expo pull request with Atlas in 2026 means leveraging an AI coding agent to go beyond line-by-line diffs, ensuring comprehensive code quality by integrating directly with your `jest-expo` test runner, `prettier` formatter, and `npx expo install` package manager. Atlas fetches the branch, reads full files for context, checks references with LSP, greps for patterns, and runs tests, all within your terminal.

How Atlas Fetches and Diffs an Expo Pull Request Branch

Atlas efficiently fetches a pull request branch and generates a comprehensive diff for your Expo project, ensuring you start every review with a clear understanding of the 100% changed code. This process uses Atlas's integrated VCS layer to interact directly with your local Git repository, providing raw patches and file status.

When you initiate a pull request review in an Expo project, Atlas first uses its internal VCS layer to interact with Git. This layer exposes `status`, `diff`, `diffRaw`, and `commits` operations, allowing Atlas to fetch the specific branch associated with the pull request. For instance, if a feature branch named `feat/new-component` is being reviewed, Atlas will use `bash` to execute the necessary Git commands to pull this branch. Once the branch is local, Atlas generates a unified diff, which is crucial for understanding the exact changes. This initial step ensures that Atlas has the most up-to-date code and a precise record of modifications, preparing it for deeper analysis of your `app.json` or `app.config.ts` files and the `app/` directory structure.

Reading Full Expo Files for Context Beyond the Diff

Atlas reads entire Expo project files, not just diff hunks, to provide crucial context that a line-by-line review might miss, especially when dealing with `expo-router` file routes or complex config plugins. This capability ensures that changes in one part of a file, like a new `app/` route, don't inadvertently break another 50 lines of unrelated code.

A common pitfall in code reviews is focusing solely on the diff hunks, which can obscure the broader impact of changes. Atlas addresses this by using its `read` tool to pull the full content of any changed file, rather than just the modified sections. For an Expo project, this is particularly vital. Imagine a change to an `expo-router` file route in `app/(tabs)/index.tsx`; seeing the entire file allows Atlas to understand how the new route fits into the existing navigation structure, or if a new component in `app/components/` is correctly imported and used elsewhere. This full-file context helps Atlas identify potential issues where a small change might have cascading effects on surrounding code, such as an updated constant in `app/constants.ts` that affects multiple components, or a modification to a `config plugin` in `plugins/my-plugin.js` that impacts the entire native build configuration.

Checking Expo Function References with LSP for Signature Changes

Atlas employs the `lsp` tool's `findReferences` operation to meticulously check for breaking changes in Expo function signatures, ensuring that a modified function in `app/utils.ts` doesn't silently break 20 other callers across your project. This proactive check is essential for maintaining code integrity in a rapidly evolving codebase.

When a function signature changes in an Expo application, a simple diff won't reveal all the places where that function is called. Atlas mitigates this risk by using the `lsp` (Language Server Protocol) tool's `findReferences` operation. For every changed function signature identified in the diff, Atlas queries the LSP server to locate all its callers throughout the entire project. This is critical for Expo projects, where a utility function in `app/lib/api.ts` or a component method in `app/components/MyComponent.tsx` might be invoked from numerous `expo-router` screens or other modules. If a function's parameters are altered, `findReferences` will highlight all call sites that need updating, even if those files were not part of the original diff. This prevents runtime errors and ensures that the refactoring or new feature doesn't introduce regressions by breaking existing functionality.

Grepping for Unupdated Patterns in Expo Codebases

Atlas uses the `grep` tool to search for patterns that should have been updated but were overlooked, such as old constant names or stale feature flags within your Expo project. This step is crucial for catching residual code, like an old `FEATURE_FLAG_V1` still present in 3 files after a migration to `FEATURE_FLAG_V2`, ensuring a clean and consistent codebase.

Beyond explicit code changes, pull requests often require updating related patterns that might not appear in the direct diff. Atlas employs the `grep` tool to proactively search for these unupdated patterns. This includes scenarios like old constant names that should have been replaced, stale copies of code, or outdated feature flags. For an Expo developer, this could mean searching for an old API endpoint string in `app/config.ts` that was replaced by a new one, or ensuring that a deprecated component name is no longer referenced in `app/screens/` or `app/components/`. Atlas can also identify if a feature flag, like `isNewFeatureEnabled`, was introduced but not consistently applied or removed after its purpose was served. This `grep` step helps maintain consistency, reduces technical debt, and ensures that all aspects of a change are thoroughly implemented across the entire Expo application, including `app.json` or `eas.json` if relevant.

Running `jest-expo` Tests and Formatting with `prettier`

Atlas integrates directly with your Expo toolchain to run `jest-expo` tests and apply `prettier` formatting, ensuring code quality and consistency before approval. This process involves Atlas executing `bash` commands like `npx jest-expo` and `npx prettier --write .` behind a permission prompt, providing a robust final check for every pull request in 2026.

A critical part of any pull request review is verifying that the changes haven't introduced new bugs and adhere to coding standards. Atlas automates this by running your project's tests and applying formatting. Using the `bash` tool, Atlas can execute `npx jest-expo` to run your unit and integration tests. This ensures that any modifications to `app/` components, `expo-router` logic, or utility functions are validated against your existing test suite. Before running, Atlas presents a permission prompt, giving you control over the execution. Following successful tests, Atlas can then apply code formatting using `prettier`. It executes `npx prettier --write .` (or a more specific path if configured) to ensure that all changed files, such as `app/screens/HomeScreen.tsx` or `app/components/Button.tsx`, conform to your project's style guidelines. This step is crucial for maintaining a consistent codebase, especially in collaborative Expo development environments, and Atlas can even stage and create commits for these formatting changes on your behalf if approved.

Atlas's Safety and Approval Workflow for Expo Reviews

Atlas prioritizes safety in every Expo pull request review, employing a multi-stage approval workflow that includes a read-only plan agent and explicit permission-gating for all tool calls. This ensures that any proposed changes, like adding a native capability via a config plugin or installing a package with `npx expo install`, are reviewed and approved by you before execution, providing 100% control.

Atlas is designed with robust safety mechanisms to ensure you maintain full control over your Expo project. Every Atlas tool call, whether it's running `jest-expo` or installing a package, is permission-gated against `allow`, `ask`, and `deny` rules. Before any action is taken, Atlas drafts a plan in a read-only plan agent, which you can review. Only after your explicit approval does it switch to a build agent to execute the plan. For instance, if Atlas suggests adding a native capability through an Expo config plugin (e.g., modifying `app.json` or `app.config.ts` to include `expo-camera` and then running `npx expo prebuild`), it will present the proposed changes and the `bash` command for `npx expo install` for your approval. Furthermore, Atlas computes a unified diff for every file edit it proposes and surfaces it for your approval before writing, allowing you to diff and roll back edits using git patches. This meticulous approval process ensures that all changes, especially those impacting `ios/` and `android/` directories via config plugins, are intentional and reproducible.

Step by step

01Atlas fetches the pull request branch using its VCS layer and the `bash` tool, producing a raw patch and file status for initial review.
02Atlas uses the `read` tool to pull the full content of all changed Expo files (e.g., `app/screens/Login.tsx`, `app/config.ts`), providing context beyond simple diff hunks.
03For every changed function signature in your Expo project, Atlas invokes the `lsp` tool's `findReferences` operation to identify and report all affected callers, even those outside the diff.
04Atlas employs the `grep` tool to search for unupdated patterns, such as old constant names or stale feature flags, across your Expo codebase (e.g., in `app/utils/constants.ts` or `app.json`).
05Atlas runs your Expo project's tests by executing `npx jest-expo` via the `bash` tool, behind a permission prompt, and reports findings as a `todowrite` list.
06Atlas applies code formatting by running `npx prettier --write .` using the `bash` tool, ensuring all changed Expo files adhere to your project's style guidelines.
07Atlas presents a unified diff for any proposed file edits (e.g., formatting changes) for your approval before writing, allowing you to accept or roll back changes.

Frequently asked questions

How does Atlas ensure my Expo project's tests run correctly during a PR review?: Atlas uses the `bash` tool to execute `npx jest-expo`, your project's designated test runner, behind a permission prompt. It then reports the findings as a `todowrite` list, ensuring all tests pass before approval.
Can Atlas help me catch unformatted code in my Expo pull requests?: Yes, Atlas integrates with `prettier`. It can execute `npx prettier --write .` via the `bash` tool to automatically format changed files in your Expo project, ensuring consistent code style.
How does Atlas handle package installations for Expo dependencies?: Atlas can install packages using `npx expo install` through the `bash` tool. This action is permission-gated, meaning Atlas will ask for your approval before installing any new dependencies or updating existing ones, ensuring versions stay pinned to your SDK release.
What if a function signature changes in my Expo app and breaks other files not in the diff?: Atlas addresses this by using the `lsp` tool's `findReferences` operation. For every changed function signature, it checks all callers across your entire Expo project, identifying any files that need updates even if they weren't part of the original diff.
Does Atlas understand Expo-specific file structures like `app/` and `app.json`?: Yes, Atlas is designed to work within Expo projects. It can read your `expo-router` routes, the plugins array in your `app.json` or `app.config.ts`, and the `eas.json` build profiles, understanding the context of your project's structure.
How does Atlas prevent unintended changes to my Expo project?: Atlas employs a multi-stage safety workflow. It drafts a plan in a read-only agent, requires explicit permission for every tool call, and surfaces a unified diff for all proposed file edits for your approval before writing, ensuring you have 100% control.
Can Atlas help with Expo config plugins during a PR review?: Yes, Atlas can review changes related to config plugins. It can even be asked to add a native capability through a config plugin rather than editing `ios/` and `android/` by hand, ensuring your `prebuild` process remains reproducible and reviewable.

Try Atlas in your terminal

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

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

Atlas for Expo: Terminal-Native AI Coding for expo-router and Config Plugins in 2026

Atlas is a terminal-native AI coding agent for Expo apps in 2026, covering expo-router file routes, config plugins, and EAS build profiles with diff-first review.

Migrate a deprecated API across every callsite in Expo with Atlas in 2026

Effortlessly migrate deprecated APIs across your entire Expo codebase using Atlas. Leverage Atlas's AI to find, replace, and verify changes with Expo's native toolchain like jest-expo and npx expo install.

Automate GitHub Issue and Pull Request Triage in Expo with Atlas in 2026

Streamline GitHub issue and PR triage for Expo apps in 2026 using Atlas. Automate responses safely, ensuring only trusted users trigger actions within your app.json or app.config.ts projects.

Rename a symbol across the repo in Expo with Atlas in 2026

In 2026, rename functions, classes, or constants across your Expo project with Atlas. Leverage `lsp` for precise references, `grep` for comments, and `edit` for safe, approved changes, ensuring your `jest-expo` tests

Onboard to an Unfamiliar Expo Codebase in 2026 with Atlas

Quickly build a mental model of any Expo project in 2026 using Atlas. Leverage semantic search, understand expo-router routes, and manage config plugins safely.

Run Atlas Headless in CI for Expo Projects in 2026

Automate Atlas in your Expo CI/CD pipelines by 2026. Get machine-readable output for `jest-expo` and `prettier` tasks, ensuring reproducible builds with `npx expo install`.

Write Unit Tests for Untested Expo Code with Atlas in 2026

Boost your Expo app's reliability in 2026 by adding unit tests with Atlas. Learn how Atlas uses `jest-expo` and `prettier` to integrate new tests direct into your existing codebase, matching your project's

Browse this resource hub