How does Atlas specifically handle Nuxt's file-based routing?

Atlas builds its code index by parsing AST declarations, which means it understands the implicit routing defined by the `pages/` directory structure in Nuxt. It can identify which `.vue` files correspond to specific routes and how dynamic routes are configured, allowing you to query the codebase about routing logic directly.

Can Atlas help me understand Nuxt's auto-imports from `composables/`?

Yes, Atlas's AST-based indexing recognizes Nuxt's auto-import mechanism. When you use the `lsp` tool's `goToDefinition` operation on an auto-imported composable within a `.vue` component or `.ts` file, Atlas can accurately navigate you to its definition in the `composables/` directory, even without an explicit import statement.

How does Atlas ensure code safety when modifying Nuxt files?

Atlas employs several safety measures. Every tool call is permission-gated, requiring your approval. Before writing any changes to Nuxt files like `nuxt.config.ts` or `.vue` components, Atlas computes and surfaces a unified diff for your review. It also drafts plans in a read-only agent and can snapshot changes as git patches for easy rollback.

Can Atlas help me refactor a `fetch` call to `useAsyncData` in Nuxt?

Absolutely. You can use the `task` tool to instruct Atlas to move a `fetch` call from a component into a `useAsyncData` hook. Atlas will draft a plan, present the proposed changes as a diff for your approval, and then execute the refactoring, ensuring the data fetching runs once during SSR as intended by Nuxt.

How does Atlas integrate with Nuxt's testing setup using `vitest (@nuxt/test-utils)`?

Atlas can be instructed to add new Nitro route handlers and then cover them with tests using `vitest` through `@nuxt/test-utils`. It understands the Nuxt testing conventions and will propose the necessary test file structure and content, presenting the changes for your review before execution, behind a permission prompt.

What if I need to explore a specific part of the Nuxt server-side logic in `server/api/`?

You can use `atlas codebase_search` to ask specific questions about your `server/api/` handlers, like 'how does the /api/auth endpoint handle user login?'. For broader investigations, delegate to the `explore` subagent with `atlas task "analyze all server/api/ endpoints for database interactions"`, which will safely `read` and `grep` relevant files.

Does Atlas support local embedding models for Nuxt code?

Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your proprietary Nuxt codebase, including sensitive logic in `server/api/` or `nuxt.config.ts`, remains entirely on your local machine, never leaving your environment for third-party servers.

Onboard to an Unfamiliar Nuxt Codebase with Atlas in 2026

Atlas empowers Nuxt developers in 2026 to rapidly build a working mental model of unfamiliar repositories by starting from meaning, not filenames. It leverages semantic search, AST indexing, and a suite of tools to navigate Nuxt's file-based routing, auto-imports, and Nitro server/client split, integrating direct with `pnpm`, `vitest (@nuxt/test-utils)`, and `prettier`.

How Atlas Understands Nuxt Project Structure and Conventions

In 2026, Atlas builds its understanding of a Nuxt project's structure by indexing AST declarations from files like `nuxt.config.ts`, `pages/`, `composables/`, and `server/api/`. This allows Atlas to respect Nuxt's unique file-based routing, auto-imports, and the server/client split managed by Nitro, providing a precise map of the codebase.

Atlas does not rely on blind line windows for code indexing; instead, it uses tree-sitter to parse AST declarations. This deep understanding is critical for Nuxt projects, where conventions dictate much of the application's behavior. For instance, Atlas recognizes that files within `pages/` define routes, `composables/` provide auto-imported utilities, and `server/api/` contains Nitro route handlers. When you run Atlas in a project containing a `nuxt.config.ts` file, it automatically begins to build this specialized index. This enables Atlas to answer questions about how specific routes are defined or where a particular composable is declared, providing context that generic search tools miss. The `glob` tool further helps by mapping the top-level directory shape, giving you an immediate overview of the package layout and naming conventions before you even open a single file.

Exploring Nuxt Codebase Semantically with Atlas

Atlas allows Nuxt developers to explore unfamiliar codebases semantically, moving beyond keyword searches to understand the 'why' behind the code. Using `codebase_search`, you can ask plain-language questions, such as 'how requests are authenticated in Nuxt?', and Atlas will return ranked snippets from relevant files, like those in `server/api/` or middleware, by 2026.

To build a working mental model without reading every file, Atlas's `codebase_search` tool is invaluable. It queries a hybrid semantic and keyword retrieval index, fused by reciprocal rank fusion, to find code snippets that match your conceptual queries. For a Nuxt developer, this means you can ask about specific Nuxt patterns, like how data fetching is handled during SSR or how a particular component uses a `useAsyncData` hook. Atlas can even build its code index with local Ollama embeddings, ensuring your proprietary Nuxt code remains off third-party servers. After `codebase_search` returns highly ranked files, you can use the `read` tool to pull only the most relevant ones. From there, the `lsp` tool's `goToDefinition` operation allows you to follow imports and declarations, tracing the flow of logic through Nuxt's auto-imports and module system, such as navigating from a component using a composable to its definition in `composables/`.

Delegating Wide Sweeps and Refactoring Nuxt Patterns

Atlas facilitates wide-ranging exploration and refactoring tasks in Nuxt projects by delegating work to specialized subagents. For example, in 2026, you can use the `task` tool to instruct an `explore` subagent to investigate all `server/api/` routes for a specific pattern, ensuring it operates within a deny-by-default permission set.

When you need to perform a broad investigation or a complex refactoring across a Nuxt codebase, Atlas's ability to fan out work to subagents becomes a powerful asset. The `explore` subagent, for instance, is defined with a deny-by-default permission set, allowing only safe operations like `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. This read-only constraint ensures that while the subagent looks around, it cannot inadvertently change anything. A Nuxt-specific example might involve asking Atlas to move a `fetch` call out of a `.vue` component into a `useAsyncData` hook, ensuring it runs once during SSR instead of twice. Atlas drafts a plan in a read-only plan agent first, asking for your approval before switching to a build agent to execute the changes. This structured approach, combined with permission gating, provides both efficiency and safety for complex Nuxt-specific tasks.

Ensuring Code Quality and Safety in Nuxt with Atlas

Atlas integrates robust safety and quality checks into the Nuxt development workflow, ensuring every change is reviewed and adheres to project standards. By 2026, Atlas computes a unified diff for every file edit and surfaces it for approval, and can automatically run `prettier` over touched `.vue` and `.ts` files.

Safety and code quality are paramount when onboarding to an unfamiliar Nuxt codebase. Atlas provides multiple layers of protection. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, giving you granular control. When Atlas proposes an edit, such as adding a new Nitro route handler in `server/api/` or covering it with `vitest` through `@nuxt/test-utils`, it computes a unified diff for every file edit and surfaces it for your approval before writing. This allows you to review the exact changes Atlas intends to make to your `.vue` components, `.ts` files, or `nuxt.config.ts`. After edits, Atlas can be instructed to run `prettier` over the touched files, ensuring consistent formatting across the codebase. Furthermore, Atlas reads git branches, status, and diffs, and can stage and create commits on your behalf, even snapshotting file changes as git patches for easy diffing and rollback, providing a comprehensive safety net for Nuxt development.

Step by step

01Initialize Atlas in your Nuxt project by running `atlas` in the directory containing `nuxt.config.ts` to allow it to index your `pages/`, `composables/`, and `server/api/` files.
02Use `atlas codebase_search "how are requests authenticated in Nuxt?"` to query the semantic index for authentication patterns, returning ranked snippets and file paths.
03Run `atlas glob "**/*"` on the top-level directories to quickly understand the Nuxt project's package layout and naming conventions before opening any files.
04Read the top two or three files identified by `codebase_search` using `atlas read <file_path>`, then use `atlas lsp goToDefinition <symbol>` to follow Nuxt-specific imports and declarations.
05Delegate a wide sweep to the `explore` subagent with `atlas task "investigate all server/api/ routes for data validation logic"`, ensuring it operates read-only.
06Ask Atlas to refactor a `fetch` call in a `.vue` component into `useAsyncData` using `atlas task "move fetch from component to useAsyncData in <component_path>"`, reviewing the proposed diff.
07Instruct Atlas to add a new Nitro route handler in `server/api/` and cover it with `vitest` using `@nuxt/test-utils`, approving the permission prompt and reviewing the diff.
08After any file edits, run `atlas task "run prettier over all touched .vue and .ts files"` to ensure consistent formatting across your Nuxt codebase.
09Record your findings and any remaining open questions as a `todowrite` list using `atlas todowrite "Investigate Nuxt module configuration in nuxt.config.ts"` to persist your mental model.

Frequently asked questions

How does Atlas specifically handle Nuxt's file-based routing?: Atlas builds its code index by parsing AST declarations, which means it understands the implicit routing defined by the `pages/` directory structure in Nuxt. It can identify which `.vue` files correspond to specific routes and how dynamic routes are configured, allowing you to query the codebase about routing logic directly.
Can Atlas help me understand Nuxt's auto-imports from `composables/`?: Yes, Atlas's AST-based indexing recognizes Nuxt's auto-import mechanism. When you use the `lsp` tool's `goToDefinition` operation on an auto-imported composable within a `.vue` component or `.ts` file, Atlas can accurately navigate you to its definition in the `composables/` directory, even without an explicit import statement.
How does Atlas ensure code safety when modifying Nuxt files?: Atlas employs several safety measures. Every tool call is permission-gated, requiring your approval. Before writing any changes to Nuxt files like `nuxt.config.ts` or `.vue` components, Atlas computes and surfaces a unified diff for your review. It also drafts plans in a read-only agent and can snapshot changes as git patches for easy rollback.
Can Atlas help me refactor a `fetch` call to `useAsyncData` in Nuxt?: Absolutely. You can use the `task` tool to instruct Atlas to move a `fetch` call from a component into a `useAsyncData` hook. Atlas will draft a plan, present the proposed changes as a diff for your approval, and then execute the refactoring, ensuring the data fetching runs once during SSR as intended by Nuxt.
How does Atlas integrate with Nuxt's testing setup using `vitest (@nuxt/test-utils)`?: Atlas can be instructed to add new Nitro route handlers and then cover them with tests using `vitest` through `@nuxt/test-utils`. It understands the Nuxt testing conventions and will propose the necessary test file structure and content, presenting the changes for your review before execution, behind a permission prompt.
What if I need to explore a specific part of the Nuxt server-side logic in `server/api/`?: You can use `atlas codebase_search` to ask specific questions about your `server/api/` handlers, like 'how does the /api/auth endpoint handle user login?'. For broader investigations, delegate to the `explore` subagent with `atlas task "analyze all server/api/ endpoints for database interactions"`, which will safely `read` and `grep` relevant files.
Does Atlas support local embedding models for Nuxt code?: Yes, Atlas can build its code index using local Ollama embeddings. This capability ensures that your proprietary Nuxt codebase, including sensitive logic in `server/api/` or `nuxt.config.ts`, remains entirely on your local machine, never leaving your environment for third-party servers.

Try Atlas in your terminal

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

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

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.

Automate GitHub Issue and Pull Request Triage in Nuxt with Atlas in 2026

Streamline GitHub issue and pull request triage for your Nuxt 3 projects in 2026 using Atlas. Configure `atlas github` in workflows, enforce trusted users, and leverage Nuxt-specific tooling like `pnpm` and `vitest`.

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.

Review a Pull Request in Nuxt with Atlas in 2026

In 2026, Nuxt developers use Atlas to review pull requests, leveraging its AI to understand diffs with full context. Atlas integrates with `pnpm`, `vitest (@nuxt/test-utils)`, and `prettier` to ensure robust code

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.

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.

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

Browse this resource hub