To plan a multi-file change in Vue before editing with Atlas, you switch to the plan agent, whose description is literally Plan mode. Disallows all edit tools. Its permission set denies edit for every path except the plan markdown under .atlas/plans/*.md, so research and design across your .vue components, stores, and router cannot accidentally turn into an edit. Atlas researches with codebase_search, grep, read, and the lsp tool, writes the plan into the allowed path, and then calls plan_exit, which asks whether to switch to the build agent and start implementing.
How do I plan a Vue refactor without an AI agent editing my components?
Atlas ships a plan agent whose description is literally Plan mode. Disallows all edit tools. Its 2026 permission set denies edit for every path and allows it only under .atlas/plans/*.md, so a design session across your .vue single-file components cannot write a single character into src/components.
Most agent accidents happen during research, when a model that was asked to think starts typing. Atlas removes the capability rather than asking the model to restrain itself. The plan agent's permission set denies edit for "*" and allows it only under .atlas/plans/*.md, which means the one place plan mode can write is the plan file itself. A Vue refactor that will eventually touch a dozen single-file components, a Pinia store under src/stores, and the router config in src/router/index.ts can therefore be fully designed with zero risk to those files. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, so the deny is enforced at the tool boundary, not by prompt instruction. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent.
What research tools stay available in Atlas plan mode for a Vue project?
Atlas keeps codebase_search, grep, read, and the lsp tool allowed in plan mode, so a Vue developer loses nothing but the ability to edit. Reading 20 .vue components, grepping for a prop name, and running findReferences on a composable all work exactly as they do in the build agent.
Plan mode is restricted, not crippled. Atlas researches with codebase_search, grep, read, and the lsp tool, and all of them stay allowed in plan mode. For a Vue project that covers the real work of designing a change: codebase_search finds which single-file components implement a behavior even when your words never appear in the template, grep locates every usage of a prop or emit across src/components/*.vue, read opens the composable in src/composables/useCart.ts, and the lsp tool's findReferences enumerates every component consuming it. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, and Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so a Composition API setup function comes back whole rather than sliced.
Where does Atlas write the plan for a Vue change?
Atlas writes the plan into the allowed plan markdown path, .atlas/plans/*.md, which is the one place plan mode can write. For a Vue migration touching 12 single-file components and a Pinia store, that markdown file is the reviewable artifact your team reads before any src/ file changes.
The plan is a real file, not a chat message, and that is deliberate. Atlas writes the plan into the allowed plan markdown path under .atlas/plans/, listing the .vue components it intends to change, the composables it will extract, the Vitest with Vue Test Utils specs it will add, and the order of operations. Because the file lives in the repo, it can be reviewed in a pull request, commented on, and revised before anyone commits to it. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so even the plan file itself lands as a diff you approve. Atlas snapshots file changes as git patches so edits can be diffed and rolled back, which makes iterating on the plan cheap.
How does plan_exit hand off to the build agent?
Atlas calls the plan_exit tool when the Vue plan is ready, which is step 4 of the documented 5-step plan-mode workflow. plan_exit asks: Plan at <path> is complete. Would you like to switch to the build agent and start implementing? Answering Yes hands off. Answering No raises Question.RejectedError and keeps you refining the plan.
The transition from thinking to editing is an explicit, gated decision in Atlas, not a drift. When the plan for your Vue change is written, Atlas calls plan_exit, which asks Plan at <path> is complete. Would you like to switch to the build agent and start implementing? A Yes moves the session into the build agent, where the edit tools become available and the .vue files under src/components can finally change. A No raises Question.RejectedError, which keeps the session in plan mode and lets you keep refining. That means a half-formed plan for a Composition API migration cannot slide into a half-executed one. The question tool is what makes the handoff a real checkpoint rather than a polite suggestion the model might skip.
How do I verify a planned Vue change once the build agent takes over?
Once Atlas switches to the build agent, the Vue plan becomes edits, and each edit is verified with Vitest with Vue Test Utils through bash. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so a 12-component migration is 12 reviewable diffs, not one.
A plan is only worth what its execution proves. After plan_exit hands off to the build agent, Atlas works through the plan file it wrote, changing one .vue single-file component at a time and running Vitest with Vue Test Utils through bash after each. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so you see each change to src/components before it exists on disk. pnpm is the package manager, so any new dependency the plan called for goes through pnpm and shows up in package.json. prettier formats the touched .vue files at the end. The documented Vue setup is exactly this loop: run atlas in a Vue project with a package.json, let Atlas read your .vue components, stores, and router, then ask Atlas to migrate to the Composition API or add Vitest tests, reviewing the diff.
Step by step
- 01Run atlas in a Vue project with a package.json so Atlas can read your .vue components, stores, and router.
- 02Switch to the plan agent; its permissions deny edit for "*" and allow it only under .atlas/plans/*.md, so no single-file component can be touched.
- 03Research with codebase_search to find which .vue components implement the behavior, even when your words never appear in the template.
- 04Grep for the prop, emit, or composable name across src/components/*.vue and src/stores to see every literal usage.
- 05Run the lsp tool's findReferences operation on the composable or store action to enumerate every component that consumes it.
- 06Write the plan into the allowed plan markdown path under .atlas/plans/, listing the .vue files to change, the Vitest with Vue Test Utils specs to add, and the order of operations.
- 07Call plan_exit: it asks Plan at <path> is complete. Would you like to switch to the build agent and start implementing?
- 08Answer Yes to hand off to the build agent; answering No raises Question.RejectedError and keeps you refining the plan.
- 09In the build agent, review the unified diff for each .vue file, run Vitest with Vue Test Utils through bash after each change, and finish with prettier.
Frequently asked questions
- how do I stop an AI coding agent from editing my Vue files while it researches
- Switch to Atlas's plan agent. Its permission set denies edit for "*" and allows it only under .atlas/plans/*.md, so a design session across your .vue single-file components structurally cannot write into src/components. The restriction is enforced at the tool boundary.
- what is plan mode in Atlas
- Plan mode is an Atlas agent whose description is literally Plan mode. Disallows all edit tools. Research tools such as codebase_search, grep, read, and the lsp tool stay allowed, and the only writable path is the plan markdown under .atlas/plans/*.md.
- how do I plan a Composition API migration across many Vue components
- Use Atlas's plan agent to research with codebase_search and the lsp tool's findReferences, then write the plan into .atlas/plans/. The plan lists every .vue component to change, the Vitest with Vue Test Utils specs to add, and the order of operations, before a single file is edited.
- what does plan_exit do in Atlas
- plan_exit asks Plan at <path> is complete. Would you like to switch to the build agent and start implementing? Answering Yes hands off to the build agent where edit tools become available. Answering No raises Question.RejectedError and keeps you refining the plan.
- can I review an AI agent's plan before it touches my Vue codebase
- Yes. Atlas writes the plan into a real markdown file under .atlas/plans/, so it lives in the repo and can be reviewed in a pull request. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent.
- does Atlas work with Vue single-file components and Pinia stores
- Yes. The documented Vue setup is to run atlas in a Vue project with a package.json and let Atlas read your .vue components, stores, and router. pnpm is the package manager, Vitest with Vue Test Utils is the test runner, and prettier is the formatter.
- what happens if I say no at the plan_exit prompt
- Answering No raises Question.RejectedError, which keeps the session in plan mode with edit still denied for every path except the plan markdown. You keep refining the plan, and no .vue file changes in the meantime.
- how does Atlas find every component that uses a Vue composable
- Atlas runs the lsp tool's findReferences operation on the composable, which returns the reference set from the language server, and cross-checks with grep across src/components/*.vue. Both tools stay allowed in plan mode, so this happens before any edit.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Plan a Multi-File Change Before Editing with Atlas in 2026
How to plan a multi-file change with Atlas in 2026: the plan agent denies all edit tools, you research with codebase_search and lsp, then plan_exit hands off.
Audit a Vue.js Repository with Parallel Subagents in Atlas, 2026
In 2026, Vue developers use Atlas to sweep entire repositories for problems without blowing the context window. Leverage parallel subagents for efficient, read-only audits of Vue.js projects.
Run Atlas Headless in CI for Vue Projects in 2026
Automate Vue development workflows in CI with Atlas. Learn how to run Atlas headless, integrate with pnpm and Vitest, and get machine-readable output for your Vue.js projects.
Automate GitHub Issue and Pull Request Triage in Vue with Atlas in 2026
Streamline GitHub issue and pull request triage in your Vue.js projects using Atlas. Configure secure, automated responses for trusted users in 2026, integrating with pnpm, Vitest, and prettier.
Extract a Shared Helper from Duplicated Code in Vue with Atlas in 2026
In 2026, Vue developers use Atlas to efficiently refactor duplicated logic into a single, tested helper. Find, extract, and replace code across .vue components and stores, ensuring maintainability with Vitest and pnpm.
Locate Where a Behavior Is Implemented in a Vue App With Atlas (2026)
Find the .vue file behind a behavior with Atlas: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph across your Vue project.
Refactor a legacy Vue module with Atlas in 2026
Refactor legacy Vue modules safely in 2026 with Atlas, the terminal-native AI coding agent. Maintain behavior, prevent breakage, and leverage Vitest and pnpm for robust Vue development.
Run the Vitest Test Suite and Triage Failures in Vue with Atlas in 2026
In 2026, Vue developers use Atlas to efficiently triage Vitest test failures. Turn a wall of red output into a prioritized list of distinct root causes, leveraging pnpm and Vue Test Utils.