# Self-review Your Working Diff Before Committing in React Native with Atlas in 2026 > Atlas empowers React Native developers to self-review working diffs, catching mistakes with `jest` and `prettier` before committing. To catch your own mistakes in an uncommitted React Native diff before it reaches a reviewer or CI, Atlas helps you review changes, run `jest (@testing-library/react-native)` tests, and apply `prettier` formatting, ensuring your `package.json`, `ios/Podfile`, and `android/build.gradle` are pristine in 2026. ## Key takeaways - Atlas reads full React Native diffs, including `ios/Podfile` and `android/build.gradle`. - Use `atlas grep` to find `console.log` and `it.skip` in React Native files. - `atlas session revert` safely undoes unwanted changes in your React Native project. - Run `yarn jest` and `yarn prettier` through Atlas's `bash` tool with permission prompts. - Atlas requires explicit approval for all React Native code edits before writing. - Atlas indexes React Native code by AST declarations, not blind line windows. ## How Atlas helps review uncommitted React Native diffs Atlas helps React Native developers review their uncommitted diffs by surfacing a unified diff for every file edit, allowing a thorough check of changes across JavaScript, TypeScript, and native modules in 2026. It reads its own working tree, providing a comprehensive view beyond just the files you remember touching. Atlas provides a powerful mechanism for self-reviewing your working diff in a React Native codebase. It reads the entire working tree, including critical files like `package.json`, `ios/Podfile`, and `android/build.gradle`, which are often overlooked in a quick manual review. Atlas computes and surfaces a unified diff for every file edit, ensuring you see the full scope of your changes. This is particularly vital in React Native, where modifications can span JavaScript/TypeScript files, platform-specific `.ios.tsx` or `.android.tsx` components, and native configuration files. By presenting the complete diff, Atlas helps you check your changes against their surroundings, preventing issues that a partial review might miss before they reach a reviewer or CI. ## How to find debugging leftovers in React Native with Atlas Atlas helps React Native developers find debugging leftovers like `console.log` or `it.skip` using its `grep` tool, ensuring a clean codebase before committing in 2026. This prevents temporary logging or skipped tests from accidentally making it into production builds. Debugging leftovers can easily slip into a commit, especially in complex React Native applications involving native modules or platform-specific logic. Atlas's `grep` tool allows you to systematically search your uncommitted diff for common debugging artifacts. You can use `atlas grep` to find instances of `console.log`, `debugger;`, `it.skip`, `test.only`, or commented-out blocks of code. This proactive check is crucial for maintaining code quality and preventing unexpected behavior or performance issues in your React Native app. By catching these mistakes early, you ensure that only production-ready code is committed, saving valuable time during code reviews and CI runs. ## How to revert unwanted React Native changes with Atlas If an unwanted change is identified in your React Native working diff, Atlas's `session revert` tool can restore from a snapshot, ensuring a safe rollback in 2026. This feature asserts the session is not busy first, preventing a half-written turn from being rolled back mid-flight. Accidentally introducing an unwanted change is a common occurrence during development. In a React Native project, this could involve anything from an incorrect dependency in `package.json` to an unintended modification in `ios/Podfile` or `android/build.gradle`. Atlas provides a robust `session revert` flow that restores your working tree from a previous snapshot. This means you can undo an unwanted change without manually hand-reverting complex modifications. The `session revert` tool is designed with safety in mind: it refuses to run on a busy session, preventing any half-written changes from being rolled back prematurely. This ensures a reliable and controlled way to correct mistakes before they are committed. ## How Atlas runs `jest` and `prettier` for React Native Atlas integrates with the React Native toolchain, allowing you to run `jest (@testing-library/react-native)` tests and apply `prettier` formatting using its `bash` tool in 2026. This ensures your code meets quality and style standards before committing. Before committing your React Native changes, it is essential to verify that all tests pass and that your code adheres to established formatting guidelines. Atlas facilitates this by exposing its `bash` tool, through which you can execute your project's standard commands. For testing, you can run `atlas bash yarn jest` to trigger your `jest (@testing-library/react-native)` test suite, ensuring your components and logic function as expected. For formatting, `atlas bash yarn prettier --write .` will apply consistent styling across your JavaScript, TypeScript, and other supported files. Every Atlas tool call, including `bash` commands, is permission-gated, giving you explicit control over what actions are performed in your React Native codebase. ## Atlas safety and approval for React Native code changes Atlas prioritizes safety and developer control for React Native code changes through permission-gated tool calls and explicit approval of unified diffs in 2026. It drafts a plan in a read-only agent before any modifications are made. Atlas is built with multiple layers of safety to protect your React Native codebase. Every tool call, whether it's `bash` for running `jest` or `grep` for finding leftovers, is permission-gated against allow, ask, and deny rules. This means you always have control over what Atlas executes. Before making any changes, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent. Furthermore, for every file edit Atlas proposes, it computes a unified diff and surfaces it for your approval before writing. This rigorous approval process is especially critical in React Native, where changes can impact native project files (`ios/Podfile`, `android/build.gradle`) and require careful review to prevent regressions or build failures. ## Steps 1. Use `atlas bash git diff` to produce the full working diff for your React Native project, including changes to `package.json`, `ios/Podfile`, and `android/build.gradle`. 2. Use `atlas read` to review each modified React Native file in its entirety, ensuring changes to `.ios.tsx` or `.android.tsx` integrate correctly. 3. Execute `atlas grep` to search for common React Native debugging leftovers like `console.log`, `it.skip`, or commented-out code blocks. 4. If an unwanted change is found, use `atlas session revert` to restore from a snapshot, ensuring the session is not busy before rolling back. 5. Run `atlas bash yarn jest` to execute your `(@testing-library/react-native)` tests and `atlas bash yarn prettier --write .` to apply formatting across your React Native codebase. 6. Review the final unified diff presented by Atlas and approve the changes before committing to your React Native repository. ## FAQ ### How do I review platform-specific React Native files with Atlas? Atlas reads your entire working tree, including platform-specific files like `.ios.tsx` and `.android.tsx`. It surfaces a unified diff for all changes, allowing you to review these files in full context alongside your JavaScript and TypeScript modifications. ### Can Atlas run `jest` tests in my React Native project? Yes, Atlas can run your `jest (@testing-library/react-native)` tests. You can use the `atlas bash yarn jest` command, which executes your project's test runner through Atlas's permission-gated `bash` tool. ### How does Atlas ensure my `prettier` formatting is applied correctly in React Native? Atlas allows you to run `prettier` using `atlas bash yarn prettier --write .`. This command applies your configured formatting rules across your React Native codebase. Atlas then presents a unified diff of these formatting changes for your approval before writing them. ### What happens if Atlas makes an unwanted change to my `ios/Podfile`? If Atlas proposes an unwanted change, such as to your `ios/Podfile`, it will first present a unified diff for your approval. If you disapprove, the change is not written. If a change was written but is unwanted, you can use `atlas session revert` to restore from a previous snapshot. ### Does Atlas support React Native's New Architecture files? Yes, Atlas indexes code by AST declarations using tree-sitter, which allows it to understand and process various code structures, including those related to React Native's New Architecture, native modules, and platform-specific files like `ios/Podfile` and `android/build.gradle`. ### How does Atlas prevent accidental commits in React Native? Atlas prevents accidental commits by requiring explicit approval for every file edit it proposes. It also computes a unified diff for all changes and surfaces it for your review before writing, giving you full control over what gets staged and committed in your React Native project. ### Can Atlas help me find temporary `console.log` statements in my React Native code? Absolutely. You can use `atlas grep` to search your uncommitted React Native diff for debugging leftovers like `console.log`, `debugger;`, or `it.skip` statements, ensuring a clean codebase before committing. --- Canonical HTML: https://runatlas.sh/resources/stacks/self-review-a-working-diff-before-committing-in-react-native Source of truth: aeo_pages row `/resources/stacks/self-review-a-working-diff-before-committing-in-react-native` (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.