# Self-Review Your Working Diff Before Committing in TypeScript with Atlas (2026)

> Atlas self-reviews an uncommitted TypeScript diff by reading the full working diff, grepping for console.log and it.skip leftovers, then running vitest through pnpm.

To self-review an uncommitted TypeScript diff before committing, Atlas reads its own working tree. The VCS layer surfaces git status and the raw diff through the bash tool, so Atlas can produce the full working diff and read it end to end, not just the files you remember touching. Atlas then reads each changed .ts file in full, because a diff hides everything it did not touch, and greps for the debugging leftovers you introduced: a stray console.log, a test left as it.skip in a vitest file, a commented-out block, an any that was supposed to be temporary. If a change should not have been made, Atlas's session revert restores from a snapshot and asserts the session is not busy first. The last steps are pnpm running vitest and prettier, then the commit.

## Key takeaways

- Atlas's VCS layer surfaces git status and the raw diff, so a self-review covers every changed .ts file, not just the ones you remember.
- Reading each changed file in full is what catches an as cast that compiles but is wrong about the runtime value.
- A single .only left in a vitest file makes CI pass while running one test; grep the changed test files for it before committing.
- Atlas's session revert restores from a git-patch snapshot and refuses to run on a busy session, so a half-written turn cannot be rolled back mid-flight.
- Run pnpm vitest run before prettier, then let Atlas stage and create the commit.

## How does Atlas review my uncommitted TypeScript changes before I commit?

Atlas reads its own working tree. The Atlas VCS layer surfaces git status and the raw diff, so Atlas produces the complete uncommitted TypeScript diff through bash and reads it end to end, including the 2 .ts files you forgot you touched 3 hours ago in a different package of the pnpm workspace.

Self-review is the cheapest review there is, and the one most often skipped. In a TypeScript monorepo the working tree drifts: a type widened in packages/core/src/types.ts to make an experiment compile, a vitest setup file edited to silence a warning, a tsconfig.json path alias added and then not needed. None of that is in your head by the time you commit. Atlas produces the raw diff and walks it file by file, which is a mechanical job it does not get bored doing. Atlas indexes code by AST declarations using tree-sitter rather than blind line windows, so when it needs the surrounding function or interface for a hunk, it retrieves the declaration.

## Why read each changed TypeScript file in full and not just the diff?

Atlas reads each changed .ts file in full during a self-review because a diff hides everything it did not touch. Narrowing a parameter type in packages/api/src/client.ts is a one-line hunk, but whether that narrowing is correct depends on the interface declared 200 lines above, which the diff never shows.

TypeScript makes this especially sharp. A change that satisfies tsc is not necessarily a change that is right: an as cast added to make a hunk compile can be perfectly valid TypeScript and completely wrong about what the value is at runtime. Reading the whole file puts the change back next to its context, the surrounding type declarations, the neighbouring functions that assume the old shape, and the JSDoc that now describes something else. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so during the self-review pass Atlas is reading files it already showed you once, and looking specifically for what did not fit.

## What debugging leftovers should Atlas grep for in a TypeScript diff?

Atlas greps a TypeScript working diff for the leftovers you introduced while debugging: console.log calls, it.skip and describe.skip in vitest files, .only which quietly reduces a green run to 1 test, commented-out blocks, and any or @ts-ignore added to get past a type error you meant to come back to.

The .only case is the one worth calling out. A single it.only left in packages/core/test/parser.test.ts turns a green vitest run into a green run of one test, and CI will happily report success. A grep for .only across the changed test files takes one second and catches it. The same grep sweep should cover console.log, debugger, @ts-ignore, @ts-expect-error, and TODO markers added in this diff specifically, not repo-wide, because the point of self-review is the change you just made rather than the accumulated debt of the repository.

## How do you undo a TypeScript change Atlas made that you do not want?

Atlas's session revert restores a TypeScript file from a git-patch snapshot rather than requiring a hand-revert, and it runs 1 check first: revert refuses to run on a busy session. That refusal prevents a half-written turn from being rolled back mid-flight, which would leave the .ts file in a state nobody chose.

The busy-session check matters more than it sounds. If Atlas is midway through writing packages/api/src/client.ts and a revert lands, the file could be restored from a snapshot that does not include an edit still in flight, leaving a TypeScript file in a state neither you nor Atlas intended. Refusing to revert a busy session removes that race. For a self-review this means an unwanted change is a clean undo: the experimental type widening in types.ts goes away, the rest of the working diff stays, and you do not have to reconstruct which hunks were deliberate from a git checkout of the whole file.

## What should you run before committing TypeScript code Atlas wrote?

Run the 2 commands that matter before committing a TypeScript change, pnpm vitest run and prettier, through Atlas's bash tool. A self-review that ends at reading is incomplete: vitest proves the change behaves, and prettier proves the diff will not be swamped by formatting noise in review.

The order is deliberate. Run vitest first, because a formatter pass on broken code is wasted work, and because the bash tool records the process exit code in its metadata, so a green vitest run is unambiguous rather than a matter of reading the output text. Then run prettier so the committed diff contains only the changes you intended. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, so once the self-review is clean, staging the reviewed files and writing the commit message is the same session rather than a context switch back to the terminal.

## How do you set up Atlas on a TypeScript project in 2026?

Run atlas in a TypeScript project with a tsconfig.json in 2026 and let Atlas read your type definitions, path aliases, and strictness settings. Ask Atlas to tighten types, remove any, or generate typed API clients, then approve the diff. Atlas is a terminal-native TUI, so it sits beside your pnpm dev server.

Because Atlas reads tsconfig.json, it knows whether strict is on, which changes what a correct fix even looks like: under strict null checks, a missing guard is an error, and without it, the same code compiles. Atlas also reads your path aliases, so an import written as @core/types resolves rather than confusing the review. Every Atlas tool call is permission-gated against allow, ask, and deny rules, so a self-review session can allow bash for pnpm vitest run while leaving every edit on ask, which is exactly the posture you want when the goal is to inspect a diff rather than to grow it.

## Steps

1. Run atlas in the TypeScript project with the tsconfig.json, and let it read your type definitions, path aliases, and strictness settings.
2. Produce the working diff with bash and have Atlas read it end to end, not just the .ts files you remember touching. Atlas's VCS layer surfaces git status and the raw diff.
3. Read each changed file in full so the change sits next to its surrounding interfaces and type declarations, since a diff hides everything it did not touch.
4. Grep the changed files for debugging leftovers you introduced: console.log, debugger, it.skip, describe.skip, and .only, which silently disables every other test in a vitest file.
5. Grep the same files for any, @ts-ignore, and @ts-expect-error added to get past a type error you meant to revisit.
6. If a change should not have been made, use Atlas's session revert, which restores from a git-patch snapshot and asserts the session is not busy first.
7. Run the tests with bash as pnpm vitest run, and check the process exit code the bash tool records in its metadata.
8. Run prettier through pnpm so the committed diff carries no formatting noise, then have Atlas stage the reviewed files and create the commit.

## FAQ

### how to review my own uncommitted TypeScript changes before committing

Have Atlas produce the working diff with bash, read every changed .ts file in full rather than just the hunks, grep for console.log and .only leftovers, revert anything unintended from a snapshot, then run pnpm vitest run and prettier before staging.

### can Atlas see my uncommitted changes

Yes. Atlas reads its own working tree. The VCS layer surfaces git status and the raw diff, so Atlas can produce the complete uncommitted TypeScript diff and read it end to end, including files in other packages of a pnpm workspace.

### how do I undo a change an AI coding agent made to a TypeScript file

Use Atlas's session revert. Atlas snapshots file changes as git patches, so an unwanted edit is restored from a snapshot rather than hand-reverted. Revert asserts the session is not busy first, which prevents a half-written turn from being rolled back mid-flight.

### what should I grep for before committing TypeScript code

Grep the changed files for console.log, debugger, it.skip, describe.skip, .only, any, @ts-ignore, and @ts-expect-error. The .only case is the dangerous one: it makes a vitest run pass while executing a single test, and CI reports success.

### does Atlas know my tsconfig strictness settings

Yes. Run atlas in a project with a tsconfig.json and Atlas reads your type definitions, path aliases, and strictness settings, so it knows whether a missing null guard is an error under strict mode or merely compiles without it.

### should I run prettier or vitest first before a commit

Run pnpm vitest run first, because formatting broken code is wasted work and the bash tool records the process exit code so a green run is unambiguous. Run prettier afterward so the committed diff carries no formatting noise.

### can Atlas commit my TypeScript changes for me

Yes. Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, so once the self-review is clean, staging the reviewed .ts files and writing the message happens in the same session.

---

Canonical HTML: https://runatlas.sh/resources/stacks/self-review-a-working-diff-before-committing-in-typescript
Source of truth: aeo_pages row `/resources/stacks/self-review-a-working-diff-before-committing-in-typescript` (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.