How does Atlas review NestJS pull requests?

Atlas reviews NestJS pull requests by fetching the diff, reading full changed files with its `read` tool, checking signature references with `lsp`, grepping for patterns, and running `jest` tests via `bash`. It focuses on providing context beyond simple line changes.

Can Atlas run `jest` tests for my NestJS project?

Yes, Atlas can run `jest` tests for your NestJS project using its `bash` tool. It can even build a `Test.createTestingModule` harness, similar to how a human developer would, behind a permission prompt to ensure safety.

How does Atlas ensure safety when modifying NestJS code?

Atlas ensures safety by using permission-gated tool calls, drafting a read-only plan in a plan agent, asking for explicit approval before switching to a build agent, and surfacing a unified diff for every file edit before writing to your NestJS project.

Does Atlas understand NestJS-specific structures like modules and DTOs?

Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand NestJS `@Module` imports and exports, provider scopes, and DTOs wired to your `ValidationPipe`. This enables more intelligent code analysis and suggestions.

What NestJS tools does Atlas integrate with?

Atlas integrates directly with standard NestJS development tools such as `jest` for testing, `pnpm` for package management, and `prettier` for code formatting. It executes these tools via its `bash` tool, respecting your project's `nest-cli.json` configuration.

How does Atlas find references for changed NestJS function signatures?

Atlas uses its `lsp` tool's `findReferences` operation to check all callers of a changed NestJS function signature, even those not visible in the initial diff. This is crucial for catching breaking changes in services, controllers, or providers across your application.

Can Atlas help with NestJS code formatting?

Yes, Atlas can help with NestJS code formatting. After reviewing changes, you can instruct Atlas to run `prettier` across the touched providers and files using its `bash` tool, ensuring your codebase adheres to consistent style guidelines.

Review a Pull Request in NestJS with Atlas in 2026

Atlas helps NestJS developers in 2026 review pull requests by going beyond simple diffs, leveraging tools like `jest` for testing, `pnpm` for package management, and `prettier` for formatting to ensure comprehensive code quality and catch bugs that a line-by-line review might miss. It integrates directly with your `nest-cli.json` and `app.module.ts` to understand your project's structure.

How Atlas Reviews NestJS Pull Requests Beyond the Diff

In 2026, Atlas reviews NestJS pull requests by first fetching the raw diff, then immediately moving beyond it to analyze the full context of changed files. This approach helps catch subtle bugs that a line-by-line diff, which only shows hunks, would inevitably miss.

Atlas initiates a NestJS pull request review by using its VCS layer to fetch the specific branch and generate the raw patch. However, a crucial step for NestJS code quality is to then use the `read` tool to pull the full content of all changed files, not just the diff hunks. This allows Atlas to understand the surrounding logic, `@Module` imports, provider scopes, and DTO definitions that might be affected by a change, even if they are outside the immediate diff. For instance, if a developer modifies a DTO wired to a `ValidationPipe`, Atlas can see the full DTO definition and its context within the module, providing a more complete picture than a simple line-by-line comparison. This comprehensive view is essential for identifying architectural issues or unintended side effects in a highly modular NestJS application.

Verifying NestJS Code Changes with `jest` and `prettier`

Atlas rigorously verifies NestJS code changes by executing the project's `jest` tests and applying `prettier` formatting, ensuring both functional correctness and adherence to coding standards. This process, critical in 2026, helps maintain high code quality across all modules and providers.

After analyzing the code context, Atlas leverages the `bash` tool to run the project's `jest` test suite. This is not a superficial check; Atlas can build a `Test.createTestingModule` harness, mimicking how a human developer would set up isolated tests for NestJS components. Before executing, Atlas presents a permission prompt, ensuring transparency and user control over potentially destructive actions. The findings from the `jest` run are then reported as a `todowrite` list, ordered by severity, highlighting any regressions or new failures. Furthermore, to maintain consistent code style across the NestJS codebase, Atlas can be instructed to run `prettier` across all touched providers and files. This ensures that the pull request adheres to the project's formatting guidelines, which are often defined in a `.prettierrc` file, preventing style-related conflicts and improving readability for other developers working with `app.module.ts` or other NestJS files.

Catching Hidden NestJS Bugs with Contextual Grep and LSP

Atlas employs advanced contextual analysis, including `grep` for pattern matching and `lsp` for `findReferences`, to uncover hidden bugs in NestJS code that a standard diff would miss. This proactive approach, vital in 2026, ensures robust changes across controllers and services.

A key part of Atlas's NestJS review workflow involves using the `grep` tool to search for specific patterns that should have been updated but were overlooked. This includes old constant names, stale copies of code, or feature flags that might have been missed in a large refactor. For example, if a constant defined in a shared utility file is changed, `grep` can identify all instances across various NestJS modules, providers, or even `nest-cli.json` configurations that still reference the old value. Simultaneously, Atlas utilizes the `lsp` tool's `findReferences` operation, especially crucial for NestJS's decorator-driven dependency injection. If a function signature in a service or controller changes, `lsp` can identify every caller, even if those callers are in files not included in the initial diff. This prevents runtime errors caused by mismatched method calls or broken dependency injections, ensuring that changes to a guard or interceptor, for instance, do not inadvertently break other parts of the application.

Atlas's Safety and Transparency in NestJS Code Reviews

Atlas prioritizes safety and transparency in every NestJS code review, ensuring that all tool calls are permission-gated and every proposed change is presented as a unified diff for explicit approval. This robust process, standard in 2026, protects your codebase from unintended modifications.

Atlas is designed with multiple layers of safety and transparency, crucial when making changes to a complex NestJS application. Every Atlas tool call, whether it's `bash` for running `pnpm install` or `lsp` for refactoring, is permission-gated against allow, ask, and deny rules. Before any modification, Atlas drafts a plan in a read-only plan agent and asks for explicit approval before switching to a build agent that can make changes. When Atlas proposes an edit, it computes a unified diff for every file, such as `app.module.ts` or a new DTO, and surfaces it for approval. This allows the NestJS developer to review the exact changes before they are written to disk. Furthermore, Atlas snapshots file changes as git patches, meaning any edits can be easily diffed and rolled back if necessary. This comprehensive safety framework ensures that even when Atlas suggests adding a guard or interceptor and registering it, the developer retains full control and visibility over the process.

Step by step

01Fetch the NestJS branch and produce the diff using Atlas's VCS layer, exposing `status`, `diff`, `diffRaw`, and `commits`.
02Read the full changed NestJS files with Atlas's `read` tool, not just the hunks, to gain context outside the immediate diff.
03For every changed NestJS function signature or DTO wired to a `ValidationPipe`, run Atlas's `lsp` tool's `findReferences` operation to check all callers.
04Use Atlas's `grep` tool to search for old NestJS constant names, stale copies, or feature flags that should have been updated but were not.
05Execute NestJS `jest` tests via Atlas's `bash` tool, potentially building a `Test.createTestingModule` harness, and report findings as a `todowrite` list.
06Review the unified diff for Atlas's proposed changes, then let Atlas run `prettier` across the touched NestJS providers and files to ensure formatting consistency.

Frequently asked questions

How does Atlas review NestJS pull requests?: Atlas reviews NestJS pull requests by fetching the diff, reading full changed files with its `read` tool, checking signature references with `lsp`, grepping for patterns, and running `jest` tests via `bash`. It focuses on providing context beyond simple line changes.
Can Atlas run `jest` tests for my NestJS project?: Yes, Atlas can run `jest` tests for your NestJS project using its `bash` tool. It can even build a `Test.createTestingModule` harness, similar to how a human developer would, behind a permission prompt to ensure safety.
How does Atlas ensure safety when modifying NestJS code?: Atlas ensures safety by using permission-gated tool calls, drafting a read-only plan in a plan agent, asking for explicit approval before switching to a build agent, and surfacing a unified diff for every file edit before writing to your NestJS project.
Does Atlas understand NestJS-specific structures like modules and DTOs?: Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand NestJS `@Module` imports and exports, provider scopes, and DTOs wired to your `ValidationPipe`. This enables more intelligent code analysis and suggestions.
What NestJS tools does Atlas integrate with?: Atlas integrates directly with standard NestJS development tools such as `jest` for testing, `pnpm` for package management, and `prettier` for code formatting. It executes these tools via its `bash` tool, respecting your project's `nest-cli.json` configuration.
How does Atlas find references for changed NestJS function signatures?: Atlas uses its `lsp` tool's `findReferences` operation to check all callers of a changed NestJS function signature, even those not visible in the initial diff. This is crucial for catching breaking changes in services, controllers, or providers across your application.
Can Atlas help with NestJS code formatting?: Yes, Atlas can help with NestJS code formatting. After reviewing changes, you can instruct Atlas to run `prettier` across the touched providers and files using its `bash` tool, ensuring your codebase adheres to consistent style guidelines.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

Plan a Multi-File Change Before Editing in NestJS with Atlas in 2026

Design and review complex, multi-file changes in your NestJS project using Atlas's plan agent. Get feedback on your strategy before modifying a single line of code, integrating with `jest`, `pnpm`, and `prettier`.

Audit a NestJS Repository with Parallel Subagents in 2026

Audit your NestJS codebase efficiently in 2026 using Atlas's parallel subagents. Sweep for problems across modules, providers, and DTOs without blowing your context window, leveraging `jest` and `prettier`.

Add a Regression Test for a Bug Fix in NestJS with Atlas in 2026

Lock in bug fixes in your NestJS applications with Atlas by adding robust regression tests. Learn how Atlas leverages `jest` and `pnpm` to implement a red-green testing workflow, ensuring your fixes are permanent and

Research a Third-Party API Before Integrating it in NestJS with Atlas in 2026

Streamline third-party API research for NestJS projects in 2026 with Atlas. Discover how Atlas uses websearch and webfetch to get current API shapes, ensuring your NestJS integration is accurate and secure, then

Run the Test Suite and Triage Failures in NestJS with Atlas in 2026

Streamline NestJS test triage in 2026 with Atlas. Turn walls of red `jest` output into prioritized, distinct root causes using `pnpm`, `grep`, and `todowrite`.

Extract a Shared Helper from Duplicated Code in NestJS with Atlas in 2026

Streamline NestJS refactoring in 2026 by extracting shared helpers from duplicated logic using Atlas. Identify semantic duplicates, create new modules, and apply changes with full reviewability, ensuring your NestJS

Self-review your working diff before committing in NestJS with Atlas in 2026

Catch your own mistakes in uncommitted NestJS diffs before code review or CI. Atlas helps NestJS developers self-review changes, run `jest` tests, and format with `prettier`.

Browse this resource hub