# Plan a multi-file change before editing in Tauri with Atlas in 2026 > Atlas enables Tauri developers to design multi-file changes, research src-tauri code, and secure review before any modifications, ensuring safety with cargo test and rustfmt. In 2026, Atlas empowers Tauri developers to meticulously design multi-file changes, ensuring comprehensive review and safety before any code modification. By leveraging its dedicated Plan agent, you can research your src-tauri Rust code, frontend JavaScript, and tauri.conf.json configurations using powerful tools like codebase_search, grep, and lsp. This read-only approach prevents accidental edits, allowing you to refine your plan for new #[tauri::command] handlers or src-tauri/capabilities entries, secure team approval, and only then proceed to implementation. Once ready, Atlas can assist with running cargo test and applying rustfmt with explicit permission, streamlining the entire development lifecycle for complex Tauri applications. ## Key takeaways - Atlas's Plan agent provides a read-only sandbox for designing complex Tauri changes. - Research #[tauri::command] handlers and src-tauri/capabilities with codebase_search and lsp before editing. - Draft multi-file plans for both Rust core and webview frontend in a dedicated markdown file. - The plan_exit tool ensures explicit approval before any Tauri code modification begins. - Atlas computes unified diffs for all proposed Tauri file edits, enabling thorough review. - Permission-gated execution of cargo test and rustfmt maintains control over your Tauri project. ## How Atlas plans multi-file Tauri changes before editing Atlas's Plan agent provides a secure environment for designing multi-file Tauri changes in 2026, preventing accidental modifications. This specialized agent operates with a strict permission set, denying all edit tools for your codebase and allowing writes only to a designated plan markdown file. This ensures that your research and design phases remain entirely read-only, safeguarding your project. When you initiate a planning session with Atlas in your Tauri project, it automatically switches to the Plan agent. This agent is specifically configured to disallow any modifications to your application's source code, including Rust files in src-tauri, frontend assets, or configuration files like tauri.conf.json. Its permission set explicitly denies edit access for all paths except those within .atlas/plans/*.md. This robust read-only mode is crucial for complex Tauri projects where a single change might span across Rust backend commands, JavaScript frontend invoke calls, and src-tauri/capabilities definitions. By enforcing this separation, Atlas guarantees that your design process is focused solely on understanding the existing architecture and outlining future modifications, without the risk of inadvertently introducing bugs or incomplete changes. This foundational safety mechanism is a core benefit for Tauri developers tackling significant refactors or new feature integrations. ## Researching Tauri project structure with Atlas's Plan agent The Atlas Plan agent offers powerful research tools to deeply understand your Tauri project's structure in 2026, all without modifying a single line. You can use codebase_search to locate #[tauri::command] handlers, grep to find specific patterns in src-tauri/tauri.conf.json, and lsp for detailed type information, ensuring a comprehensive understanding of your application's 100+ files. Within the Plan agent, Atlas provides a suite of tools designed for in-depth code exploration. For a Tauri project, this means you can use codebase_search to quickly find all instances of #[tauri::command] attributes in your Rust code, identifying existing IPC handlers. The grep tool allows you to search for specific strings or patterns across your entire project, invaluable for inspecting src-tauri/tauri.conf.json for configuration details or frontend/package.json for dependencies. The read tool enables you to view the contents of any file, such as src-tauri/main.rs or a specific JavaScript module in your frontend. Furthermore, the lsp tool provides semantic understanding, allowing you to query for type definitions, references, and implementations within your Rust core, giving you precise insights into how different parts of your Tauri application interact. All these tools operate within the read-only constraints of the Plan agent, ensuring that your research activities are entirely non-destructive. This capability is essential for designing changes that correctly integrate with both the Rust backend and the webview frontend, respecting the specific idioms of the Tauri framework. ## Drafting and refining your Tauri change plan Once your research is complete, Atlas guides you in drafting a detailed plan for your Tauri modifications, ensuring clarity and preventing premature code changes. The Plan agent's sole write permission is directed to a markdown file, typically located at .atlas/plans/my_tauri_feature.md, allowing you to iterate on your design without affecting your 1.0 production codebase. The core output of the Plan agent is a markdown document where you articulate your proposed multi-file change. This document serves as a blueprint, detailing which #[tauri::command] handlers might be added or modified, how invoke calls in the frontend will interact with them, and any necessary adjustments to src-tauri/capabilities to grant the required permissions. Atlas ensures that this plan is the only artifact you can modify during this phase. You can use the question tool to prompt Atlas for clarification or suggestions as you write, leveraging its understanding of your codebase. This iterative process allows you to refine your design, considering all implications across the Rust core, the webview frontend, and the security model defined by capabilities. By having a concrete, written plan, you can easily share it for review with teammates, ensuring alignment and catching potential issues before any actual development work begins. This structured approach is particularly beneficial for complex Tauri features that touch multiple layers of the application. ## Ensuring safety and review for Tauri modifications Atlas provides robust mechanisms to ensure safety and facilitate review for your planned Tauri modifications, preventing unapproved changes from reaching your codebase. After drafting your plan, the plan_exit tool prompts for approval to switch to the build agent, which then computes a unified diff for every proposed file edit, offering a final review before any of the 2026 code is written. The transition from planning to implementation in Atlas is explicitly permission-gated. When your plan is complete, you invoke the plan_exit tool. This tool presents a clear prompt: "Plan at is complete. Would you like to switch to the build agent and start implementing?" Answering "Yes" signals your intent to proceed, handing off control to the build agent. Answering "No" raises a Question.RejectedError, keeping you in the Plan agent to further refine your design. Once in the build agent, Atlas continues its safety protocols. Every proposed file edit, whether it's a change to src-tauri/main.rs, a new JavaScript file in the frontend, or an update to src-tauri/capabilities, is first presented as a unified diff. This diff allows you to meticulously review the exact changes Atlas intends to make. Furthermore, Atlas's tool calls are permission-gated; for instance, running cargo test in src-tauri or rustfmt on your Rust code will require explicit approval, ensuring that automated actions align with your intentions. This multi-layered approval process guarantees that all Tauri modifications are thoroughly reviewed and explicitly sanctioned before they become part of your project. ## Steps 1. Initialize Atlas in your Tauri project: Ensure your project contains src-tauri/tauri.conf.json and a frontend/package.json for Atlas to index. 2. Switch to the Plan agent: Type `atlas plan` or follow the prompt to enter the read-only planning mode. 3. Research your Tauri codebase: Use `codebase_search "#[tauri::command]"` to locate existing IPC handlers, `grep "invoke"` to find frontend calls, or `read src-tauri/capabilities` to inspect permissions. 4. Inspect specific Tauri files: Utilize `lsp` on Rust files in src-tauri for semantic information, or `read frontend/src/App.jsx` to understand frontend components. 5. Draft your multi-file change plan: Write your detailed design into the allowed markdown file, for example, `.atlas/plans/new_feature_design.md`, outlining changes to Rust, frontend, and tauri.conf.json. 6. Refine and review your plan: Iterate on the markdown document, using Atlas's research tools as needed, and share the plan for human review. 7. Call `plan_exit` to propose implementation: When the plan is finalized, execute `plan_exit` and confirm "Yes" to switch to the build agent. 8. Approve proposed Tauri code changes: Review the unified diffs for all file modifications (e.g., src-tauri/main.rs, frontend/src/api.js, src-tauri/capabilities/default.json) and approve them before Atlas writes to disk. 9. Approve `cargo test` and `rustfmt` execution: Grant permission for Atlas to run `cargo test` in src-tauri and `rustfmt` on the Rust side, and potentially `pnpm test` and `prettier` on the frontend, to validate and format the new code. ## FAQ ### How does Atlas prevent accidental edits in my Tauri project during planning? Atlas's Plan agent operates in a strict read-only mode, denying all edit tools for your Tauri codebase. It only permits writing to a designated plan markdown file, ensuring your src-tauri and frontend code remains untouched during the design phase. ### Can Atlas help me understand my existing #[tauri::command] handlers and invoke calls? Yes, Atlas's Plan agent provides codebase_search to find #[tauri::command] attributes in Rust, grep for invoke calls in your frontend, and lsp for semantic details, giving you a full picture of your IPC. ### What Tauri-specific files can Atlas read during the planning phase? Atlas can read any file in your Tauri project, including src-tauri/tauri.conf.json, src-tauri/capabilities, Rust files in src-tauri, and all frontend files like package.json or JavaScript/TypeScript modules. ### How does Atlas ensure my planned Tauri changes are safe before implementation? Atlas uses the plan_exit tool to require explicit approval before switching to an editing agent. Once in the build agent, every proposed file modification is presented as a unified diff for your review, and tools like cargo test and rustfmt require permission to run. ### Can Atlas help me add a new capability entry to src-tauri/capabilities? While in the Plan agent, Atlas helps you research and plan for such an addition. Once you transition to the build agent, Atlas can draft the necessary changes to src-tauri/capabilities and present them as a diff for your approval before writing. ### Does Atlas support both the Rust core and the frontend parts of a Tauri app? Absolutely. Atlas is designed to work across the entire Tauri stack, understanding Rust code in src-tauri, JavaScript/TypeScript in your frontend, and the interaction points defined by #[tauri::command] and invoke calls. ### What happens if I decide not to implement a plan after calling plan_exit? If you answer "No" to the plan_exit prompt, Atlas raises a Question.RejectedError and keeps you in the Plan agent. This allows you to continue refining your plan without committing to implementation. --- Canonical HTML: https://runatlas.sh/resources/stacks/plan-a-multi-file-change-before-editing-in-tauri Source of truth: aeo_pages row `/resources/stacks/plan-a-multi-file-change-before-editing-in-tauri` (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.