# Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow) > Atlas can read its own working tree: the VCS layer surfaces status and the raw diff, and every edit Atlas made is recoverable from a snapshot. To catch your own mistakes in the uncommitted diff before they reach a reviewer or CI, have Atlas read its own working tree. Atlas produces the working diff with bash and reads it end to end, not just the files you remember touching, then reads each changed file in full to check the change against its surroundings, since a diff hides everything it did not touch. Atlas greps for the debugging leftovers you introduced: temporary logging, skipped tests, commented-out blocks. If a change should not have been made, Atlas's session revert restores from a snapshot and asserts the session is not busy first. Then bash runs the tests and the linter, and you commit. ## Key takeaways - Atlas can read its own working tree: the VCS layer surfaces status and the raw diff, so the review runs on evidence, not memory. - Read the changed files in full, because a diff hides everything it did not touch, including the guard clause your edit contradicts. - Grep for temporary logging, skipped tests, and commented-out blocks. None of them break the build, so nothing else catches them. - Session revert restores from a snapshot and refuses to run on a busy session, so a half-written turn is never rolled back mid-flight. - Run the tests and the linter with bash before the commit, not after the push. ## How do I self-review my uncommitted changes with Atlas? Atlas self-reviews a working diff in 5 steps: bash produces the diff, read opens each changed file in full, grep hunts for debugging leftovers, session revert undoes any change that should not have been made, and bash runs the tests and the linter before you commit. The step people skip is the first one, because they think they already know what they changed. They do not. A working tree accumulates edits from a long session, and the file you touched two hours ago to test a theory is still touched. Atlas produces the working diff with bash and reads it end to end, not just the files you remember touching. The gap between what you believe your diff contains and what it actually contains is where the embarrassing commit comes from. ## How does Atlas read the working diff with bash? Atlas produces the working diff with bash, and Atlas's VCS layer surfaces status and the raw diff over the same git data. In a 2026 self-review the status output is what catches the file you forgot you edited, and the raw diff is what shows exactly what changed inside it. Status and diff answer two different questions. Status answers which files are dirty, which is how a stray edit to a config file or a lockfile surfaces at all. The raw diff answers what changed inside them, line by line. Reading both in sequence is what turns a self-review from a memory exercise into an evidence exercise. Every bash command Atlas runs is permission-gated against allow, ask, and deny rules before it runs, so the git commands can sit on allow while anything with side effects still asks. ## Why does Atlas read the full file and not just the diff? Atlas reads each changed file in full with the read tool because a diff hides everything it did not touch. A four-line edit can look correct in isolation and still contradict a guard clause 40 lines above it that the diff never shows and you never reopened. Self-review has a specific failure mode: you reread your own diff and see what you intended, because you wrote it. Reading the full file breaks that loop by putting the change back into a context you did not author in that moment. The early return you added skips a cleanup path. The field you set is consumed by a branch that runs before your code. The function you shortened is called from a path where the removed check mattered. All of that is invisible in the diff and visible in the file. ## How do I find debugging leftovers before committing? Atlas greps the working tree for the debugging leftovers you introduced: temporary logging, skipped tests, commented-out blocks. These are the 3 leftovers most likely to reach a reviewer, because none of them break the build and none of them fail a test, so nothing else catches them. The grep step is aimed at the artifacts of your own process rather than at correctness. A print statement added to trace a value. A test marked skip while you chased a different failure. A block commented out rather than deleted, kept because you were not sure you would need it back. Each one is harmless in the moment and each one is a review comment or a silent gap in coverage once it is committed. Grepping for them is faster and more reliable than remembering them. ## How do I undo a change Atlas made that I do not want? Atlas's session revert restores from a snapshot rather than making you hand-revert the file, because Atlas snapshots file changes as git patches so edits can be diffed and rolled back. Revert has 1 guard: it refuses to run on a busy session, preventing a half-written turn from being rolled back mid-flight. The busy-session guard is the part that matters in practice. Rolling back while a turn is still writing would leave the working tree in a state that matches neither the snapshot nor the intended result, and Atlas asserts the session is not busy first rather than letting that happen. Because the snapshots are git patches, a revert is an ordinary diff operation and not a special recovery mode. If you decide mid-review that one of Atlas's edits was wrong, you revert it instead of unpicking it by hand. ## What should I run before committing a working diff? Atlas runs the tests and the linter with bash, then commits. Running both before the commit rather than after the push is the difference between a 30 second local failure and a red CI pipeline that every other person on the branch has to wait behind in 2026. The commit itself is still yours to approve. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, but every bash command it runs is permission-gated against allow, ask, and deny rules before it runs, and any file Atlas edits with the edit tool produces a unified diff surfaced for approval before writing. A self-review that ends with a green test run, a clean lint, and a diff you have actually read end to end is a commit that will not come back to you. ## Steps 1. Produce the working diff with bash and read it end to end, not just the files you remember touching. 2. Read each changed file in full with the read tool to check the change against its surroundings, since a diff hides everything it did not touch. 3. Grep for the debugging leftovers you introduced: temporary logging, skipped tests, commented-out blocks. 4. Fix what the review turns up with the edit tool, which surfaces a unified diff for approval before writing. 5. If a change should not have been made at all, use Atlas's session revert, which restores from a snapshot and asserts the session is not busy first. 6. Run the tests and the linter with bash, confirm both are clean, then commit. ## FAQ ### how do I review my own code changes before committing Have Atlas produce the working diff with bash and read it end to end, read each changed file in full to see the context the diff hides, grep for debugging leftovers, then run the tests and the linter with bash before you commit. ### how do I find leftover debug logging before I commit? Grep the working tree for the leftovers you introduced during the session: temporary logging, skipped tests, and commented-out blocks. None of them fail a test or break a build, so grep is the only thing that reliably catches them before a reviewer does. ### can Atlas undo an edit it made in the current session? Yes. Atlas snapshots file changes as git patches, and the session revert flow restores from a snapshot rather than requiring a hand revert. Revert asserts the session is not busy first, so a turn that is still writing cannot be rolled back mid-flight. ### why does Atlas revert refuse to run? Revert refuses to run on a busy session. The guard prevents a half-written turn from being rolled back mid-flight, which would leave the working tree matching neither the snapshot nor the intended result. Wait for the session to go idle and run it again. ### does reading the diff catch every mistake in my changes? No. A diff hides everything it did not touch, so a correct-looking hunk can still contradict a guard clause or a cleanup path elsewhere in the same file. Atlas reads each changed file in full with the read tool for exactly that reason. ### does Atlas ask before it edits a file during a self-review? Yes. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, and Atlas computes a unified diff for every file edit and surfaces it for approval before writing. The edit tool never lands a change you have not seen. ### can Atlas commit for me after the self-review? Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf. The staging and the commit still run through the permission gate, so you approve them like any other command. --- Canonical HTML: https://runatlas.sh/resources/workflows/self-review-a-working-diff-before-committing Source of truth: aeo_pages row `/resources/workflows/self-review-a-working-diff-before-committing` (segment: Workflows) (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.