How does Atlas handle Nuxt's auto-imports during dependency upgrades?

Atlas indexes your `composables/` and `pages/` directories using tree-sitter, understanding Nuxt's auto-imports. When fixing code with `edit`, it respects these conventions, ensuring fixes integrate correctly without breaking implicit imports in your Nuxt application.

Can Atlas upgrade a specific Nuxt dependency to a major version?

Yes, Atlas uses the `bash` tool to execute `pnpm upgrade @latest` or `pnpm add @ ` directly. It then proceeds to fix any resulting compile or test failures across your Nuxt project, ensuring a smooth transition.

How does Atlas ensure my Nuxt code remains formatted after fixes?

After making code changes, Atlas can invoke `prettier --write .` via its `bash` tool. This ensures all `.vue` and `.ts` files modified during the upgrade process adhere to your project's `prettier` configuration, maintaining consistent code style across your Nuxt codebase.

What if the dependency's breaking changes are complex for Nuxt?

Atlas uses `webfetch` to retrieve the library's release notes and changelogs. This provides the agent with context on actual breaking changes, allowing it to make more informed fixes to your Nuxt components, composables, and Nitro handlers, even for complex migrations.

How does Atlas integrate with `vitest (@nuxt/test-utils)` for testing?

Atlas runs your tests using `pnpm test` or `vitest` via its `bash` tool. It parses the output from `vitest (@nuxt/test-utils)` to identify failing tests, then uses its `edit` tool to iteratively fix the underlying issues in your Nuxt application until all tests pass.

Is it safe to let Atlas modify my Nuxt project files?

Yes, Atlas prioritizes safety. Every tool call is permission-gated, and it drafts a plan in a read-only agent first. All file edits are presented as a unified diff for your approval before being written to disk. You retain full control over changes to your `nuxt.config.ts` or other files.

Can Atlas help move data fetching to `useAsyncData` in Nuxt?

Yes, as part of its Nuxt-specific capabilities, Atlas can identify `fetch` calls within components and, with your permission, refactor them into `useAsyncData` composables. This optimizes data fetching for SSR, ensuring it runs once during server-side rendering instead of twice in your Nuxt application.

How does Atlas handle Nuxt's server/client split (Nitro)?

Atlas is aware of Nuxt's server/client split and Nitro handlers in `server/api/`. When upgrading dependencies or fixing code, it understands the context of server-side versus client-side execution, ensuring fixes are applied appropriately to avoid runtime issues in your Nuxt application.

Upgrade a Nuxt Dependency and Fix Breakage with Atlas in 2026

Atlas empowers Nuxt developers in 2026 to confidently upgrade dependencies to new major versions and automatically repair all resulting compile and test failures. By deeply integrating with the Nuxt toolchain, including `pnpm` for package management, `vitest (@nuxt/test-utils)` for testing, and `prettier` for formatting, Atlas provides a terminal-native AI agent that understands your project's specific needs and idioms. This ensures that your Nuxt application remains functional and well-maintained even after significant library updates.

How Atlas upgrades Nuxt dependencies and identifies breaking changes

Upgrading a Nuxt dependency to a new major version in 2026 can introduce significant breaking changes, but Atlas streamlines this process. Atlas uses its `bash` tool to execute `pnpm upgrade <package-name>@latest`, capturing the full output to understand the initial state and any immediate warnings.

Atlas initiates the dependency upgrade by directly interacting with your Nuxt project's package manager. Using the `bash` tool, it runs `pnpm upgrade <package-name>@latest` to bump the specified library. The complete output from `pnpm` is captured and, if extensive, saved to a file for Atlas to `read`. Following the upgrade, Atlas proactively uses `webfetch` to retrieve the official release notes and changelogs for the newly upgraded package. This crucial step ensures that Atlas has the actual context of breaking changes, rather than guessing, allowing it to make precise and informed fixes across your Nuxt application's `.vue` components, `composables/`, and `server/api/` handlers. This approach respects Nuxt's file-based routing and auto-import conventions from the outset.

Repairing Nuxt compile errors after a major dependency bump

After a dependency upgrade, Nuxt projects often encounter compile errors, which Atlas systematically addresses. Atlas leverages its `bash` tool to run `pnpm run build` (or `nuxi build`), allowing the Nuxt compiler to enumerate every breakage, rather than predicting them. This ensures 100% of reported errors are targeted.

Once the dependency is upgraded, Atlas shifts its focus to resolving compile-time issues. It executes `pnpm run build` (or `nuxi build`) via the `bash` tool, directly reading the compiler's output to identify specific errors. For each reported error, Atlas employs its `edit` tool to modify the affected `.vue` and `.ts` files. To ensure accuracy, Atlas utilizes the `lsp` tool's `goToDefinition` operation. This allows it to inspect the new function signatures, class definitions, or type declarations within the upgraded package's `node_modules` directory. This deep understanding of the new API surface, combined with Atlas's awareness of Nuxt's file-based routing and auto-imports, enables it to apply precise fixes that align with the framework's idioms, such as correctly updating `useAsyncData` calls or Nitro route handlers.

Fixing Nuxt test failures with `vitest (@nuxt/test-utils)` and Atlas

A successful dependency upgrade in Nuxt requires passing all tests, a task Atlas handles iteratively. Atlas runs your test suite using `pnpm test` (which invokes `vitest (@nuxt/test-utils)`) via its `bash` tool, identifying and fixing failures until 0 tests remain broken. This iterative process ensures comprehensive coverage.

After addressing compile errors, Atlas turns its attention to ensuring the Nuxt application's test suite passes. It executes `pnpm test` (which typically runs `vitest (@nuxt/test-utils)` in a Nuxt project) using the `bash` tool. Atlas parses the output from `vitest (@nuxt/test-utils)` to pinpoint specific test failures. For each failing test, Atlas uses its `edit` tool to modify the relevant source code or test files. This might involve updating component props in `.vue` files, adjusting composable logic in `composables/`, or correcting API responses in `server/api/` handlers. Atlas continuously re-runs `pnpm test` after each set of fixes, iterating until the entire test suite, powered by `vitest (@nuxt/test-utils)`, reports a clean run, confirming the stability of the upgraded Nuxt application.

Ensuring code quality and safety with Atlas in Nuxt projects

Atlas prioritizes safety and code quality throughout the Nuxt dependency upgrade process in 2026. Before any changes are applied, Atlas drafts a read-only plan, and every tool call is permission-gated, giving you 100% control over modifications to your `nuxt.config.ts` or other project files.

Atlas is designed with multiple layers of safety and quality assurance for your Nuxt projects. Before executing any modifications, Atlas's plan agent drafts a comprehensive, read-only plan, which you review and approve. Every subsequent tool call, whether `bash`, `edit`, or `webfetch`, is permission-gated against allow, ask, or deny rules, ensuring you maintain full control. For every file edit, Atlas computes a unified diff and surfaces it for your approval, allowing you to inspect changes to `.vue` components, `.ts` files, or `nuxt.config.ts` before they are written. After fixes are applied, Atlas can invoke `prettier --write .` via `bash` to ensure all touched `.vue` and `.ts` files adhere to your project's formatting standards. Atlas also reads git branches and status, and can stage and create commits on your behalf, with snapshots of file changes available for easy rollback, providing a secure and auditable upgrade path for your Nuxt application.

Step by step

01Run `pnpm upgrade <package-name>@latest` using Atlas's `bash` tool to initiate the dependency upgrade in your Nuxt project.
02Use Atlas's `webfetch` tool to retrieve the official release notes and changelogs for the upgraded Nuxt dependency.
03Execute `pnpm run build` (or `nuxi build`) with Atlas's `bash` tool to identify and enumerate all compile errors in your Nuxt application.
04Fix each compile error in `.vue` and `.ts` files using Atlas's `edit` tool, leveraging `lsp.goToDefinition` to inspect new API signatures in the upgraded package.
05Re-run `pnpm run build` (or `nuxi build`) and `pnpm test` (which uses `vitest (@nuxt/test-utils)`) with Atlas's `bash` tool until all compile errors are resolved and all tests pass.
06Let Atlas run `prettier --write .` over all touched `.vue` and `.ts` files using its `bash` tool to ensure consistent formatting.
07Review the comprehensive unified diff presented by Atlas for all proposed changes to your Nuxt project before approving them.
08Allow Atlas to stage and create a git commit on your behalf, documenting the successful dependency upgrade and fixes.

Frequently asked questions

How does Atlas handle Nuxt's auto-imports during dependency upgrades?: Atlas indexes your `composables/` and `pages/` directories using tree-sitter, understanding Nuxt's auto-imports. When fixing code with `edit`, it respects these conventions, ensuring fixes integrate correctly without breaking implicit imports in your Nuxt application.
Can Atlas upgrade a specific Nuxt dependency to a major version?: Yes, Atlas uses the `bash` tool to execute `pnpm upgrade <package-name>@latest` or `pnpm add <package-name>@<major-version>` directly. It then proceeds to fix any resulting compile or test failures across your Nuxt project, ensuring a smooth transition.
How does Atlas ensure my Nuxt code remains formatted after fixes?: After making code changes, Atlas can invoke `prettier --write .` via its `bash` tool. This ensures all `.vue` and `.ts` files modified during the upgrade process adhere to your project's `prettier` configuration, maintaining consistent code style across your Nuxt codebase.
What if the dependency's breaking changes are complex for Nuxt?: Atlas uses `webfetch` to retrieve the library's release notes and changelogs. This provides the agent with context on actual breaking changes, allowing it to make more informed fixes to your Nuxt components, composables, and Nitro handlers, even for complex migrations.
How does Atlas integrate with `vitest (@nuxt/test-utils)` for testing?: Atlas runs your tests using `pnpm test` or `vitest` via its `bash` tool. It parses the output from `vitest (@nuxt/test-utils)` to identify failing tests, then uses its `edit` tool to iteratively fix the underlying issues in your Nuxt application until all tests pass.
Is it safe to let Atlas modify my Nuxt project files?: Yes, Atlas prioritizes safety. Every tool call is permission-gated, and it drafts a plan in a read-only agent first. All file edits are presented as a unified diff for your approval before being written to disk. You retain full control over changes to your `nuxt.config.ts` or other files.
Can Atlas help move data fetching to `useAsyncData` in Nuxt?: Yes, as part of its Nuxt-specific capabilities, Atlas can identify `fetch` calls within components and, with your permission, refactor them into `useAsyncData` composables. This optimizes data fetching for SSR, ensuring it runs once during server-side rendering instead of twice in your Nuxt application.
How does Atlas handle Nuxt's server/client split (Nitro)?: Atlas is aware of Nuxt's server/client split and Nitro handlers in `server/api/`. When upgrading dependencies or fixing code, it understands the context of server-side versus client-side execution, ensuring fixes are applied appropriately to avoid runtime issues in your Nuxt application.

Try Atlas in your terminal

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

Install Atlas

Related guides

Upgrade a Dependency and Fix the Breakage with Atlas (2026 Workflow)

How to upgrade a dependency and fix the breakage with Atlas in 2026: bash drives the package manager, webfetch pulls the release notes, edit fixes each compiler error.

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.

Locate where a behavior is implemented in Nuxt with Atlas in 2026

Pinpoint the exact file and symbol responsible for any Nuxt behavior using Atlas in 2026. Leverage semantic search, `grep`, and LSP to navigate Nuxt's file-based routing and auto-imports.

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.

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

Refactor a legacy module in Nuxt with Atlas in 2026

Streamline your Nuxt 3 project by refactoring legacy modules with Atlas. Safely restructure code, maintain behavior, and prevent breaking changes using `vitest` and `pnpm` in 2026.

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

Audit a Nuxt.js Repository with Parallel Subagents in 2026 using Atlas

Sweep your Nuxt.js repository for issues without context window limits. Atlas uses parallel subagents to audit code, respecting Nuxt's file-based routing and auto-imports.

Browse this resource hub