Atlas helps Expo developers in 2026 catch their own mistakes in uncommitted diffs by providing a terminal-native interface to review changes, find debugging leftovers, and run essential tools like `jest-expo` and `prettier` before committing. It integrates directly with your Expo project, understanding `app.json` or `app.config.ts` and `expo-router` routes.
How do I review my Expo working diff with Atlas?
Atlas helps you review your Expo working diff by surfacing the unified diff directly in your terminal, allowing you to read it end to end, not just the files you remember touching. In 2026, Atlas reads git branches, status, and diffs, providing a comprehensive view of all 100% of your uncommitted changes.
When working on an Expo project, Atlas connects to your local Git repository to read the current status and generate a unified diff of all uncommitted changes. This means you don't have to manually run `git diff` or remember every file you've modified. Atlas presents this diff in its terminal-native TUI, allowing you to scroll through every line of every changed file. This is particularly useful for Expo projects where changes might span across `app.json`, `app.config.ts`, `app/` directory files for `expo-router` routes, or even `eas.json` build profiles. By presenting the entire diff, Atlas ensures you catch unintended modifications or forgotten changes that might otherwise slip through to a reviewer or CI.
How does Atlas help check Expo file changes against surrounding code?
Atlas helps you check Expo file changes against their surroundings by allowing you to read each changed file in full, not just the diff. A standard diff hides everything it did not touch, but Atlas's deep understanding of your code, built with local Ollama embeddings and AST declarations, provides the full context for your 2026 Expo project.
While a unified diff is excellent for seeing what changed, it inherently hides the surrounding code that was not modified. This can lead to overlooking context-dependent issues, especially in complex Expo components or `expo-router` route files. Atlas addresses this by allowing you to view the entire file content, even for files with only a few lines changed. Atlas indexes your code using AST declarations via tree-sitter, providing a structural understanding of your Expo application. This means Atlas can present changes within the full context of your `app/` directory components, `app.json` or `app.config.ts` configurations, or custom config plugins, helping you verify that your modifications align with the existing codebase's logic and style.
How can Atlas find debugging leftovers in my Expo app?
Atlas can efficiently find debugging leftovers in your Expo app by leveraging its `grep` tool, allowing you to search for common patterns like temporary logging or skipped tests. This helps ensure that `console.log` statements, `debugger;` calls, or `jest-expo`'s `it.only` and `describe.skip` don't make it into your 2026 production builds.
Debugging code, such as `console.log` statements, `debugger;` calls, or commented-out blocks, can easily be forgotten in a working diff. For Expo projects, this also includes specific `jest-expo` test runner idioms like `it.only` or `describe.skip` that temporarily isolate tests. Atlas provides a powerful `grep` tool that you can direct to search your working tree for these common debugging patterns. For example, you can ask Atlas to `grep` for 'console.log' across your `app/` directory or 'it.only' within your test files. This proactive search helps you identify and remove these leftovers before they reach a reviewer or impact your CI/CD pipeline, maintaining the cleanliness and performance of your Expo application.
How do I revert unwanted changes in my Expo project using Atlas?
You can revert unwanted changes in your Expo project using Atlas's session revert feature, which restores from a snapshot of your working tree. This powerful capability, backed by git patches, ensures that any unintended modifications to your `app.json` or `app.config.ts` can be undone safely, provided the session is not busy, preventing mid-flight rollbacks in 2026.
Sometimes, during the self-review process, you might identify changes that should not have been made or that introduce new issues. Atlas provides a robust session revert mechanism to undo these unwanted modifications. Every edit Atlas makes is recoverable, as it snapshots file changes as git patches. If you decide a change is incorrect, you can use Atlas's session revert flow to restore your project to a previous state. A critical safety feature is that Atlas refuses to run revert on a busy session, preventing a half-written turn from being rolled back mid-flight. This ensures the integrity of your Expo project's configuration files, such as `app.json`, `app.config.ts`, or `eas.json`, and your codebase, allowing for confident experimentation and correction.
How does Atlas run Expo tests and linting before committing?
Atlas runs your Expo tests and linter before committing by executing real commands like `npx jest-expo` and `npx prettier --write .` through its permission-gated `bash` tool. This ensures your code adheres to quality standards and passes all 100% of your tests, providing a final verification step in 2026 before your changes are staged.
A crucial part of self-review is verifying that your changes haven't introduced regressions and adhere to your project's coding standards. Atlas integrates with your Expo toolchain to run tests and linting. You can instruct Atlas to use its `bash` tool to execute `npx jest-expo` to run your unit and integration tests. Similarly, for code formatting, Atlas can run `npx prettier --write .` to automatically format your code according to your project's `prettier` configuration. Every Atlas tool call, including `bash` commands, is permission-gated, meaning Atlas will ask for your approval before running these commands. After running, Atlas computes a unified diff for any file edits (e.g., from `prettier`) and surfaces it for your approval before writing, ensuring you have full control over the final state of your Expo codebase before committing.
Step by step
- 01Start Atlas in your Expo project directory, ensuring `app.json` or `app.config.ts` is present.
- 02Ask Atlas to 'show me the working diff' to review all uncommitted changes across your Expo app.
- 03Instruct Atlas to 'grep for debugging leftovers' like `console.log` or `it.only` within your `app/` directory.
- 04If any changes are unwanted, use Atlas's session revert feature to restore from a previous snapshot.
- 05Ask Atlas to 'run the Expo tests' which will execute `npx jest-expo` behind a permission prompt.
- 06Instruct Atlas to 'format the code' which will run `npx prettier --write .` and present a diff for approval.
- 07Review the final unified diff presented by Atlas, including any changes made by `prettier`.
- 08Approve Atlas to stage and create the commit on your behalf, finalizing your self-review.
Frequently asked questions
- How does Atlas handle `expo-router` routes during review?
- Atlas indexes code by AST declarations using tree-sitter, allowing it to understand the structure of your `expo-router` file routes within the `app/` directory. This deep understanding helps Atlas present changes in context and ensures that modifications to your routing logic are accurately reviewed.
- Can Atlas install Expo packages like `npx expo install`?
- Yes, Atlas can install packages using `npx expo install`. It exposes the `bash` tool, which is permission-gated, allowing you to instruct Atlas to run this command. This ensures that package versions stay pinned to your SDK release, maintaining consistency in your Expo project.
- What happens if Atlas tries to revert a busy Expo session?
- Atlas's session revert flow includes a safety mechanism: it refuses to run on a busy session. This prevents a half-written turn or an active agent process from being rolled back mid-flight, ensuring the integrity of your Expo project and preventing data loss.
- Does Atlas use local embeddings for Expo code?
- Yes, Atlas can build its code index with local Ollama embeddings. This means that your Expo project's code, including sensitive configurations in `app.json` or `app.config.ts`, remains on your machine and off third-party servers, enhancing privacy and security.
- How does Atlas ensure my Expo config plugins are reproducible?
- Atlas encourages adding native capabilities through config plugins rather than editing `ios/` and `android/` directories by hand. By letting Atlas manage these changes, it helps ensure that your `prebuild` process remains reproducible and consistent across environments, which is crucial for EAS builds.
- Can Atlas format my Expo code with `prettier`?
- Absolutely. Atlas can run `prettier` on your Expo codebase. You can instruct Atlas to execute `npx prettier --write .` using its `bash` tool. After formatting, Atlas will present a unified diff of the changes for your approval before writing them to disk, giving you full control.
- How does Atlas run `jest-expo` tests?
- Atlas runs `jest-expo` tests by executing `npx jest-expo` via its permission-gated `bash` tool. This allows you to integrate your existing test suite into your self-review workflow, ensuring that your changes pass all tests before they are committed, directly within the Atlas TUI.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow)
How to self-review your working diff before committing with Atlas in 2026: bash produces the diff, read checks each file, grep finds leftovers, session revert undoes bad edits.
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.
Locate Expo Behavior Implementations with Atlas in 2026
Pinpoint exact file and symbol locations for any behavior in your Expo application using Atlas. Leverage semantic search, grep, and LSP tools for precise code navigation in 2026.
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.
Plan a Multi-File Change in Expo with Atlas in 2026
Design complex, multi-file changes for your Expo app in 2026 using Atlas. Plan and get review before modifying a single line, leveraging `jest-expo` and `prettier` for a safe workflow.
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
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
Diagnose a hanging or long-running command in Expo with Atlas in 2026
Atlas helps Expo developers in 2026 diagnose and unblock hanging `npx expo install` or `jest-expo` commands, distinguishing slow operations from interactive input waits. Get unstuck fast.