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.
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.
Step by step
- 01Run atlas in the TypeScript project with the tsconfig.json, and let it read your type definitions, path aliases, and strictness settings.
- 02Produce 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.
- 03Read 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.
- 04Grep 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.
- 05Grep the same files for any, @ts-ignore, and @ts-expect-error added to get past a type error you meant to revisit.
- 06If 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.
- 07Run the tests with bash as pnpm vitest run, and check the process exit code the bash tool records in its metadata.
- 08Run prettier through pnpm so the committed diff carries no formatting noise, then have Atlas stage the reviewed files and create the commit.
Frequently asked questions
- 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.
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 TypeScript in 2026
In 2026, TypeScript developers leverage Atlas, the terminal-native AI coding agent, to enhance productivity. Atlas understands your types, ensures code quality, and offers robust safety features.
Write Unit Tests for Untested Code in TypeScript with Atlas (2026)
How Atlas writes vitest unit tests for untested TypeScript in 2026: lsp documentSymbol enumerates exports, grep copies your conventions, and pnpm vitest actually runs them.
Refactor a legacy module in TypeScript with Atlas (2026)
Refactor a legacy TypeScript module in 2026 with Atlas: map callsites with lsp findReferences, restructure with apply_patch, and prove behavior with vitest.
Automate GitHub Issue and Pull Request Triage in TypeScript with Atlas (2026)
Wire the atlas github command into a TypeScript repo's Actions workflow in 2026: set MODEL in provider/model form, gate on write permission, verify with vitest.
Review a TypeScript Pull Request with Atlas (2026)
Review a TypeScript pull request with Atlas in 2026. Get the raw diff with bash, read changed files in full, and check callers with lsp findReferences before running vitest.
Diagnose a hanging or long-running command in TypeScript with Atlas (2026)
Is your pnpm build slow or blocked on stdin? Atlas's bash timeout message tells you which, in 2026, and how to unstick vitest, tsc, and prettier runs that never finish.
Plan a Multi-File Change Before Editing in TypeScript with Atlas (2026)
Atlas plans multi-file TypeScript changes in a read-only plan agent that denies every edit tool, so you approve the design before pnpm, vitest, or prettier ever run.