# Onboard to an unfamiliar codebase in NestJS with Atlas in 2026 > Atlas empowers NestJS developers to quickly grasp new codebases by intelligently navigating modules, providers, and DTOs, avoiding the need to read every file. Atlas helps NestJS developers in 2026 rapidly build a mental model of unfamiliar codebases by leveraging semantic search, AST indexing, and permission-gated tools, integrating directly with `pnpm`, `jest`, and `prettier` for a streamlined workflow. ## Key takeaways - Atlas uses semantic search to understand NestJS modules, providers, and DTOs without reading every file. - Explore NestJS project structure with `glob` and follow dependencies using `lsp`'s `goToDefinition`. - Delegate complex NestJS code sweeps to the read-only `explore` subagent for safe investigation. - Review all proposed NestJS code changes via unified diffs before Atlas writes them. - Atlas integrates with `jest` for testing and `prettier` for formatting NestJS code. - Atlas can build its code index with local Ollama embeddings, keeping NestJS code private. ## How does Atlas help me understand a NestJS codebase quickly? Atlas helps NestJS developers in 2026 quickly grasp unfamiliar codebases by starting from meaning, not filenames. It uses `codebase_search` to query a semantic index built with local Ollama embeddings, returning ranked snippets and file paths, often reducing initial exploration time by over 50%. Atlas begins by indexing your NestJS codebase using AST declarations via tree-sitter, rather than relying on blind line windows. This allows it to understand the structural components of NestJS, such as `@Module` imports and exports, provider scopes, and DTOs wired to your `ValidationPipe`. When you ask `codebase_search` a plain-language question, for example, 'how are requests authenticated?', Atlas queries this semantic index. It returns highly ranked code snippets and their file paths, like `src/auth/auth.module.ts` or `src/guards/jwt-auth.guard.ts`, providing immediate context without requiring you to manually search through every file. This process can be powered by local Ollama embeddings, ensuring your NestJS code remains off third-party servers. ## How do I explore NestJS project structure and dependencies with Atlas? To understand the layout of a NestJS project, Atlas allows you to run `glob` on top-level directories, revealing package structure and naming conventions in under 10 seconds. This initial scan helps identify key areas like `src/modules` or `src/common` before diving into specific files. After an initial semantic search, Atlas enables you to quickly map the directory shape of a NestJS project. Running the `glob` tool on top-level directories provides an overview of the package layout and naming conventions, helping you identify common NestJS patterns like `src/modules`, `src/providers`, or `src/dto`. Once you have identified the two or three most relevant files from `codebase_search`, you can use the `read` tool to inspect their contents. From there, the `lsp` tool's `goToDefinition` operation becomes invaluable for navigating NestJS dependencies. You can follow `@Module` imports, trace provider injections, or jump to the definition of a DTO, building a precise mental model of how different NestJS components interact without extensive manual file navigation. ## How does Atlas handle deep dives and wide sweeps in NestJS code? For extensive exploration within a NestJS repository, Atlas delegates wide sweeps to the `explore` subagent, which operates with a deny-by-default permission set. This subagent can perform tasks like `grep` across 100s of files or `websearch` for NestJS best practices, all while ensuring no code changes occur. When your investigation requires a broader scope, Atlas allows you to delegate complex or wide-ranging tasks to the `explore` subagent using the `task` tool. This subagent is specifically designed for read-only operations, ensuring that it cannot inadvertently modify your NestJS codebase. Its permission set is deny-by-default, only allowing tools like `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. For instance, you could task the `explore` subagent to 'find all usages of the `@Controller('api/v1')` decorator across the entire project' or 'list all DTOs that use the `class-validator` library'. This capability is crucial for understanding cross-cutting concerns or architectural patterns within a large, unfamiliar NestJS application without manually sifting through countless files. ## How does Atlas ensure safety and review when making changes in NestJS? Atlas prioritizes safety and developer control, ensuring every proposed change in a NestJS codebase is thoroughly reviewed. It drafts a plan in a read-only agent, asks for approval before switching to a build agent, and computes a unified diff for every file edit, which you must approve before writing, typically in under 5 seconds. Before any modification is made to your NestJS codebase, Atlas employs a robust safety mechanism. It first drafts a comprehensive plan in a read-only plan agent, detailing the steps it intends to take. This plan is presented for your review and approval. Only after your explicit consent does Atlas switch to a build agent. Every tool call made by Atlas is permission-gated, allowing you to set 'allow', 'ask', or 'deny' rules. Crucially, for every file edit, Atlas computes a unified diff and surfaces it for your approval. This means if Atlas suggests adding a new guard to `app.module.ts` or modifying a provider in `src/users/users.module.ts`, you will see the exact line-by-line changes before they are written to disk, providing complete control and transparency over your NestJS project. ## How does Atlas integrate with NestJS testing and formatting tools? Atlas integrates with standard NestJS development tools, including the `jest` test runner and the `prettier` formatter. After making changes, Atlas can build a `Test.createTestingModule` harness and run `jest` behind a permission prompt, ensuring code quality and adherence to project standards in 2026. Atlas is designed to work direct within your existing NestJS development environment. When you're ready to validate changes, Atlas can build a `Test.createTestingModule` harness, a common NestJS testing utility, and then execute your tests using the `jest` test runner. This operation is permission-gated, requiring your approval before running, ensuring you maintain control over your testing workflow. Furthermore, Atlas understands the importance of code consistency. After any modifications, such as adding a new provider or updating a DTO, you can let Atlas run `prettier` across the touched files. This ensures that your NestJS codebase adheres to the project's formatting standards, as defined in your `prettier.config.js` or similar configuration, maintaining code quality and readability across all modules and services. ## Steps 1. Run `atlas` in your NestJS project, ensuring `nest-cli.json` and `app.module.ts` are present for Atlas to index. 2. Ask `codebase_search` a plain-language question, such as "how are requests authenticated in NestJS?", to find relevant modules and providers. 3. Execute `glob` on top-level directories to understand the NestJS package layout and naming conventions, like `src/modules` or `src/common`. 4. Use `read` on the top two or three files identified by `codebase_search`, then follow NestJS `@Module` imports and provider injections with the `lsp` tool's `goToDefinition`. 5. Delegate wide sweeps to the `explore` subagent via the `task` tool, for example, "task: find all DTOs wired to a `ValidationPipe` across the codebase." 6. Record your findings and open questions as a `todowrite` list, ensuring your mental model evolves with each turn. 7. If making changes, let Atlas draft a plan, review the unified diff, and approve before it runs `prettier` across touched NestJS providers. 8. Allow Atlas to build a `Test.createTestingModule` harness and run `jest` behind a permission prompt to validate any proposed NestJS changes. ## FAQ ### How does Atlas understand my NestJS project's structure? Atlas indexes your NestJS code by AST declarations using tree-sitter, not blind line windows. It specifically reads your `@Module` imports and exports, provider scopes, and DTOs wired to your `ValidationPipe`, starting from files like `nest-cli.json` and `app.module.ts`. ### Can Atlas help me find specific NestJS services or controllers? Yes, use `codebase_search` with a plain-language query like "find the `UserService` provider" or "show me the `AuthController`." Atlas queries its semantic index to return ranked snippets and file paths relevant to your NestJS components. ### How does Atlas ensure it doesn't accidentally change my NestJS code? Atlas operates with strict safety measures. Every tool call is permission-gated against allow, ask, and deny rules. It drafts plans in a read-only agent, and any file edit generates a unified diff for your explicit approval before writing. The `explore` subagent is also read-only by default. ### Can Atlas help me add a new NestJS guard or interceptor? Absolutely. You can ask Atlas to add a guard or interceptor, and it will register it where it belongs, rather than sprinkling logic in controllers. It will then present a diff for your review and approval, ensuring proper integration into your NestJS application. ### How does Atlas integrate with NestJS testing? Atlas can build a `Test.createTestingModule` harness for your NestJS application and run the `jest` test runner behind a permission prompt. This allows you to validate changes and ensure test coverage directly within your workflow, adhering to NestJS testing best practices. ### What NestJS tools does Atlas support for code quality? Atlas integrates directly with `prettier` for code formatting. After making changes, you can let Atlas run `prettier` across the touched providers, ensuring your NestJS codebase adheres to consistent style guidelines and maintains high code quality. ### Can Atlas work with local embedding models for NestJS code? Yes, Atlas can build its code index with local Ollama embeddings, keeping your sensitive NestJS code off third-party servers. This provides an additional layer of privacy and security for your development environment, especially for proprietary NestJS projects. --- Canonical HTML: https://runatlas.sh/resources/stacks/onboard-to-an-unfamiliar-codebase-in-nestjs Source of truth: aeo_pages row `/resources/stacks/onboard-to-an-unfamiliar-codebase-in-nestjs` (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.