How does Atlas understand Nuxt's file-based routing and auto-imports?

Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand Nuxt's specific project structure, including `pages/` for routing and `composables/` for auto-imports. This deep structural awareness enables it to analyze changes in context, respecting how Nuxt organizes and connects code.

Can Atlas run `vitest` for my Nuxt project?

Yes, Atlas can run `vitest` for your Nuxt project. It uses its `bash` tool to execute `pnpm vitest`, leveraging `@nuxt/test-utils` to run your test suite. Atlas then reports the test results as a `todowrite` list, highlighting any failures or regressions introduced by the pull request.

How does Atlas ensure code style in Nuxt `.vue` and `.ts` files?

Atlas integrates with `prettier`, the common formatter for Nuxt projects. After reviewing or making edits, Atlas can run `pnpm prettier --write .` over the touched `.vue` and `.ts` files, ensuring that all code adheres to your project's defined formatting standards before committing.

Does Atlas modify my Nuxt code without permission?

No, Atlas never modifies your Nuxt code without explicit permission. It drafts a plan in a read-only agent and asks for approval. For every proposed file edit, Atlas computes a unified diff and surfaces it for your approval before writing, giving you granular control over changes to `nuxt.config.ts` or any other file.

How does Atlas catch bugs that a simple diff misses in Nuxt?

Atlas catches subtle bugs by going beyond the raw diff. It reads full Nuxt files (not just hunks) for complete context and uses its `lsp` tool to `findReferences` for changed function signatures, identifying impacts on callers in `pages/` or `server/api/` that were not part of the original diff. It also `grep`s for outdated patterns.

Can Atlas help with Nuxt's server/client split (Nitro)?

Yes, Atlas is designed to respect Nuxt's server/client split, including Nitro. It can analyze changes in `server/api/` handlers, understand how `useAsyncData` fetches data once during SSR, and ensure that modifications are consistent with Nuxt's universal rendering architecture.

What package manager does Atlas use for Nuxt projects?

Atlas respects your Nuxt project's configured package manager. For projects using `pnpm`, Atlas will use `pnpm` for commands like `pnpm install` or `pnpm vitest`, ensuring direct integration with your existing development environment.

Review a Pull Request in Nuxt with Atlas in 2026

In 2026, Nuxt developers can efficiently review pull requests with Atlas by leveraging its deep understanding of the Nuxt project structure, including `pages/` routes and `composables/` auto-imports, alongside real toolchain commands like `pnpm install` and `vitest (@nuxt/test-utils)`. Atlas fetches the diff, reads full files for context, and uses `lsp` to check for breaking changes, ensuring a comprehensive review that goes beyond a simple line-by-line inspection.

How Atlas Reviews Nuxt Pull Requests for Context

Atlas reviews Nuxt pull requests by first fetching the branch and generating a unified diff using `bash`, then reading the full changed files, not just hunks, to provide 100% complete context. This process ensures that even subtle changes in `pages/` or `composables/` are understood within their broader file structure.

Atlas initiates a pull request review by interacting with your local Git repository. It uses its VCS layer to expose `status`, `diff`, `diffRaw`, and `commits` operations, mirroring standard `git` commands. For a Nuxt project, this means Atlas can fetch a specific branch and produce a raw patch, allowing it to see all modifications across `.vue`, `.ts`, and other relevant files. Crucially, Atlas then employs its `read` tool to pull the *entire* content of changed files, rather than just the diff hunks. This is vital for Nuxt, where a small change in a `composables/` file might have implications for auto-imports across many components, or a modification in `server/api/` could affect a Nitro handler's behavior. By reading the full file, Atlas ensures it has the complete surrounding context, preventing the oversight of bugs that a line-by-line diff might miss. This comprehensive approach is a cornerstone of Atlas's review process, ensuring that the AI agent has all the necessary information to make informed suggestions and identify potential issues.

Verifying Nuxt Changes with LSP and Grep

Atlas verifies Nuxt changes by leveraging the `lsp` tool to `findReferences` for every modified function signature, ensuring no callers in `pages/` or `server/api/` are broken, even if the diff doesn't show them. It also uses `grep` to find 0 instances of old constant names or stale copies that should have been updated.

After understanding the full context of changed files, Atlas moves to a deeper analysis using specialized tools. For Nuxt applications, where reactivity and auto-imports are central, a change to a function signature in a `composables/` file could have widespread, non-obvious impacts. Atlas addresses this by using its `lsp` (Language Server Protocol) tool to perform `findReferences` operations on every modified function or variable signature. This allows Atlas to identify all call sites, even those in files not directly touched by the pull request's diff, such as a `.vue` component in `pages/` or a utility function in `server/utils/`. This proactive check catches breaking changes that a human reviewer might easily miss. Furthermore, Atlas employs the `grep` tool to search for specific patterns that *should* have been updated but might have been overlooked. This includes old constant names, stale copies of code, or feature flags that were meant to be removed or modified. For instance, if a global constant defined in `nuxt.config.ts` or a shared utility in `plugins/` was refactored, Atlas can `grep` for its old name to ensure all references have been updated, providing an additional layer of review rigor.

Running Nuxt Tests and Formatting with Atlas

Atlas ensures Nuxt code quality by running tests with `pnpm vitest` through `@nuxt/test-utils` and then applying `prettier` to touched `.vue` and `.ts` files, all behind a permission prompt. This guarantees that 100% of the changes adhere to project standards and pass existing test suites.

A critical step in any pull request review is validating the changes against the existing test suite and code style guidelines. Atlas integrates directly with the Nuxt ecosystem's preferred tools to automate this. It executes tests using `bash` with the command `pnpm vitest`, leveraging `@nuxt/test-utils` for a robust testing environment. This ensures that any modifications to `server/api/` handlers, `composables/`, or `pages/` components do not introduce regressions or break existing functionality. Atlas reports the findings of these test runs as a `todowrite` list, ordered by severity, making it easy for the developer to address critical issues first. Beyond functionality, code consistency is paramount. After the review and potential edits, Atlas can run `prettier` over the touched `.vue` and `.ts` files. This ensures that all new or modified code adheres to the project's formatting standards, maintaining a clean and readable codebase. Every Atlas tool call, including running `vitest` or `prettier`, is permission-gated against `allow`, `ask`, and `deny` rules, providing the developer with full control and transparency over the agent's actions. This ensures that Atlas acts as a helpful assistant, not an autonomous override.

Atlas's Safety and Control in Nuxt Workflows

Atlas provides robust safety and control for Nuxt developers by drafting a read-only plan before executing any changes, and then presenting a unified diff for every file edit for approval. This ensures 100% transparency and prevents unintended modifications to `nuxt.config.ts` or other critical project files.

Atlas is designed with developer control and safety as a core principle, especially when interacting with complex Nuxt projects. Before making any modifications, Atlas operates in a read-only plan agent, where it drafts a detailed plan of action. This plan is presented to the developer for review and approval, ensuring that the proposed steps align with the developer's intent for the Nuxt codebase. Only after explicit permission does Atlas switch to a build agent to execute the plan. Furthermore, for every file edit Atlas proposes, it computes a unified diff and surfaces it for approval *before* writing any changes to disk. This granular control means a developer can review exactly what Atlas intends to change in a `pages/` route, a `composables/` utility, or even the `nuxt.config.ts` file. Atlas also snapshots file changes as Git patches, allowing edits to be easily diffed and rolled back if necessary. This level of transparency and permission-gating ensures that Nuxt developers maintain full oversight, preventing any unexpected or unwanted alterations to their project, and fostering trust in the AI agent's capabilities.

Step by step

01Fetch the Nuxt branch and generate the diff: Atlas uses `bash` to `git fetch origin <branch-name>` and then `git diff <base-branch> <branch-name>` to produce the raw patch, identifying all changed files in your Nuxt project.
02Read full Nuxt files for context: Atlas employs its `read` tool to pull the complete content of all modified `.vue` and `.ts` files, including those in `pages/`, `composables/`, and `server/api/`, ensuring context beyond the diff hunks is visible.
03Check Nuxt function references with LSP: For every changed function signature within your Nuxt codebase, Atlas's `lsp` tool runs `findReferences` to identify and report any callers in other `.vue` or `.ts` files that the diff might not have touched, preventing silent breakages.
04Grep for stale Nuxt patterns: Atlas uses `grep` to search for old constant names, deprecated feature flags, or stale code copies across your Nuxt project, such as in `plugins/` or `utils/`, that should have been updated by the pull request.
05Run Nuxt tests with Vitest: Atlas executes `pnpm vitest` via `bash`, leveraging `@nuxt/test-utils`, to run the entire test suite for your Nuxt application, reporting any failures or regressions as a `todowrite` list ordered by severity.
06Format Nuxt files with Prettier: After review and potential edits, Atlas can run `pnpm prettier --write .` over the touched `.vue` and `.ts` files, ensuring all modifications adhere to your Nuxt project's established code formatting standards.

Frequently asked questions

How does Atlas understand Nuxt's file-based routing and auto-imports?: Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand Nuxt's specific project structure, including `pages/` for routing and `composables/` for auto-imports. This deep structural awareness enables it to analyze changes in context, respecting how Nuxt organizes and connects code.
Can Atlas run `vitest` for my Nuxt project?: Yes, Atlas can run `vitest` for your Nuxt project. It uses its `bash` tool to execute `pnpm vitest`, leveraging `@nuxt/test-utils` to run your test suite. Atlas then reports the test results as a `todowrite` list, highlighting any failures or regressions introduced by the pull request.
How does Atlas ensure code style in Nuxt `.vue` and `.ts` files?: Atlas integrates with `prettier`, the common formatter for Nuxt projects. After reviewing or making edits, Atlas can run `pnpm prettier --write .` over the touched `.vue` and `.ts` files, ensuring that all code adheres to your project's defined formatting standards before committing.
Does Atlas modify my Nuxt code without permission?: No, Atlas never modifies your Nuxt code without explicit permission. It drafts a plan in a read-only agent and asks for approval. For every proposed file edit, Atlas computes a unified diff and surfaces it for your approval before writing, giving you granular control over changes to `nuxt.config.ts` or any other file.
How does Atlas catch bugs that a simple diff misses in Nuxt?: Atlas catches subtle bugs by going beyond the raw diff. It reads full Nuxt files (not just hunks) for complete context and uses its `lsp` tool to `findReferences` for changed function signatures, identifying impacts on callers in `pages/` or `server/api/` that were not part of the original diff. It also `grep`s for outdated patterns.
Can Atlas help with Nuxt's server/client split (Nitro)?: Yes, Atlas is designed to respect Nuxt's server/client split, including Nitro. It can analyze changes in `server/api/` handlers, understand how `useAsyncData` fetches data once during SSR, and ensure that modifications are consistent with Nuxt's universal rendering architecture.
What package manager does Atlas use for Nuxt projects?: Atlas respects your Nuxt project's configured package manager. For projects using `pnpm`, Atlas will use `pnpm` for commands like `pnpm install` or `pnpm vitest`, ensuring direct integration with your existing development environment.

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.

Atlas for Nuxt: Auto-Imports, useAsyncData, and Nitro Handlers in 2026

Atlas is a terminal-native AI coding agent for Nuxt in 2026. It reads nuxt.config.ts, pages/ routes, composables/ auto-imports, and server/api/ Nitro handlers, and tests with @nuxt/test-utils.

Self-review Your Working Diff Before Committing in Nuxt with Atlas in 2026

Catch your own mistakes in uncommitted Nuxt diffs before they reach review or CI. Use Atlas to review changes, run vitest, pnpm, and prettier, and safely revert unwanted edits.

Debug a single failing test in Nuxt with Atlas in 2026

Pinpoint and fix failing Nuxt tests with Atlas in 2026. Leverage vitest (@nuxt/test-utils) and pnpm for efficient debugging, code navigation, and precise fixes in your Nuxt 3 application.

Trace a runtime bug from a stack trace in Nuxt with Atlas in 2026

Pinpoint Nuxt runtime bugs from production stack traces using Atlas in 2026. Leverage Atlas to navigate `pages/` routes, `composables/` auto-imports, and `server/api/` Nitro handlers, ensuring a swift fix and regression

Onboard to an Unfamiliar Nuxt Codebase with Atlas in 2026

Quickly build a working mental model of any Nuxt.js repository using Atlas. Leverage semantic search, AST indexing, and permission-gated tools to understand file-based routing, auto-imports, and Nitro handlers without

Write unit tests for untested code in Nuxt with Atlas in 2026

Learn how Atlas helps Nuxt developers in 2026 add real unit tests to untested modules using `vitest (@nuxt/test-utils)`, `pnpm`, and `prettier`, matching existing repo conventions.

Upgrade a Nuxt Dependency and Fix Breakage with Atlas in 2026

Effortlessly upgrade Nuxt dependencies to new major versions and resolve compile or test failures using Atlas. Leverage pnpm, vitest, and prettier for a streamlined, safe migration process in 2026.

Browse this resource hub