# Onboard to an Unfamiliar Blazor Codebase with Atlas in 2026 > Atlas empowers Blazor developers to rapidly grasp new Blazor codebases by combining semantic search with familiar tools like `dotnet test (bUnit)` and `NuGet`. In 2026, Atlas helps Blazor developers quickly build a working mental model of unfamiliar codebases by leveraging semantic search, `dotnet test (bUnit)`, `NuGet (dotnet add package)`, and `dotnet format` to understand project structure and logic without reading every file. It starts from meaning, not just filenames, to guide you through `.razor` components and C# services. ## Key takeaways - Atlas uses semantic search to understand Blazor code, not just filenames. - The `explore` subagent provides safe, read-only sweeps of Blazor repositories. - Atlas integrates directly with `dotnet test (bUnit)` and `dotnet format` for Blazor. - `lsp goToDefinition` helps trace Blazor component dependencies and C# services. - `todowrite` captures Blazor-specific learning and open questions. - Atlas requires explicit approval for all changes to your Blazor codebase. ## How does Atlas help me understand a Blazor project's structure? Atlas helps you understand a Blazor project's structure in 2026 by starting with meaning, not just filenames. It uses `codebase_search` to query a semantic index, returning ranked snippets from `.razor` components and C# files, often highlighting key areas within 3-5 top files. This approach quickly reveals core concepts. To build a working mental model of an unfamiliar Blazor repository, Atlas begins by indexing your code using AST declarations via tree-sitter, not blind line windows. This means Atlas understands the actual structure of your `.razor` components, C# classes, and `.csproj` files. When you ask `codebase_search` a plain-language question, such as "how are requests authenticated in this Blazor application?", Atlas queries this semantic index. It returns highly relevant code snippets and their file paths, allowing you to pinpoint critical areas without sifting through countless files. Following this, you can run `glob` on the top-level directories to quickly grasp the overall package layout and naming conventions specific to the Blazor project, such as where `.razor` components might reside versus C# service implementations. ## How does Atlas explore Blazor code and follow dependencies? To explore Blazor code and follow dependencies, Atlas leverages its `lsp` tool for `goToDefinition` operations, allowing you to trace calls across `.razor` components and C# files. This is crucial for understanding how a component's `@code` block interacts with services, often revealing 1-2 layers of abstraction quickly. Once you've identified initial files using `codebase_search`, Atlas allows you to dive deeper into the Blazor codebase. You can `read` the two or three files `codebase_search` ranked highest. From there, the `lsp` tool's `goToDefinition` operation becomes invaluable. This allows you to follow imports and method calls directly, tracing how a Blazor component in a `.razor` file uses a C# service, or how cascading parameters are passed. Atlas understands Blazor-specific constructs like `@rendermode` directives and `IJSRuntime` interop calls, enabling it to accurately work through the complex dependency graph of a modern Blazor application. This targeted exploration prevents you from getting lost in irrelevant files, focusing your attention on the actual flow of logic. ## How does Atlas ensure safety when exploring an unfamiliar Blazor codebase? Atlas ensures safety when exploring an unfamiliar Blazor codebase by using a read-only `explore` subagent, which operates with a deny-by-default permission set. This subagent can only execute 6 specific tools: `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`, preventing any accidental modifications to your `.csproj` or `.razor` files. Safety is paramount when exploring an unfamiliar Blazor codebase. Atlas addresses this by delegating wide sweeps and exploratory tasks to its `explore` subagent. This subagent is explicitly defined with a deny-by-default permission set, meaning it cannot make any changes to your files unless explicitly allowed. It is restricted to a specific set of read-only tools: `grep`, `glob`, `read`, `bash`, `webfetch`, and `websearch`. This robust permission model ensures that while the `explore` subagent can thoroughly investigate your Blazor project's `.razor` components, C# services, and configuration files, it cannot accidentally modify or delete anything. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, providing an additional layer of control and peace of mind. ## How does Atlas integrate with Blazor's testing and formatting tools? Atlas integrates direct with Blazor's testing and formatting tools, allowing you to add `bUnit` component tests and run `dotnet test` behind a permission prompt. After approving the diff, Atlas can then execute `dotnet format` to ensure code consistency across your `.razor` and C# files, streamlining 2 key development tasks. Atlas is designed to work within your existing Blazor development workflow, not replace it. It understands and integrates with the real Blazor toolchain. For testing, Atlas can help you add `bUnit` component tests to your `.razor` components and then run `dotnet test` to execute them. Before any test code is written or executed, Atlas will present a permission prompt for your approval. Similarly, for code consistency, after any modifications or additions, Atlas can run `dotnet format` across your entire Blazor solution, ensuring that all C# and `.razor` files adhere to your team's coding standards. Every file edit Atlas proposes is presented as a unified diff for your approval, giving you full control before any changes are written to disk. This ensures that Atlas acts as an intelligent assistant, augmenting your Blazor development process. ## How does Atlas help me document my Blazor onboarding process? Atlas helps you document your Blazor onboarding process by using the `todowrite` tool to record open questions and insights. This ensures that as you navigate `.razor` components and C# services, your learning is captured, allowing you to maintain a clear list of 3-5 next steps or areas for deeper investigation. Building a mental model of a new Blazor codebase involves asking many questions and uncovering new information. Atlas provides the `todowrite` tool to help you record what you've learned and keep track of open questions. As you explore `.razor` components, understand C# service interactions, or investigate `NuGet` package dependencies, you can use `todowrite` to jot down insights, potential issues, or areas that require further investigation. This ensures that your learning process is documented and persistent, allowing you to pick up exactly where you left off in the next turn. This feature is crucial for complex Blazor projects where understanding the interplay of render modes, cascading parameters, and `IJSRuntime` calls can be intricate. ## Steps 1. Start Atlas in your Blazor solution with `.razor` components and a `.csproj` targeting the Blazor SDK. 2. Ask Atlas: `codebase_search "how are requests authenticated in this Blazor application?"` to semantically query the codebase. 3. Run `glob "**/*"` to map the top-level directories and understand the Blazor project's package layout and naming conventions. 4. Use `read ` on the 2-3 highest-ranked files from `codebase_search`, then follow Blazor-specific imports with `lsp goToDefinition`. 5. Delegate wide sweeps to the read-only `explore` subagent using `task "explore the data access layer for Blazor components"`. 6. Record your findings and open questions using `todowrite "Investigate Blazor render modes for component X"`. 7. Let Atlas add `bUnit` component tests and run `dotnet test` after a permission prompt. 8. Approve the unified diff for any changes, then let Atlas run `dotnet format` to ensure Blazor code style. ## FAQ ### How does Atlas handle Blazor's different render modes? Atlas reads `@rendermode` directives within your `.razor` components. It can help you understand how components are rendered and even assist in moving a component to `InteractiveServer` or `InteractiveWebAssembly`, fixing state serialization issues that may arise. ### Can Atlas understand C# and JavaScript interop in Blazor? Yes, Atlas reads `IJSRuntime` interop calls within your Blazor application. This allows it to understand the boundary and interactions between your C# backend logic and JavaScript frontend code, providing a complete view of your Blazor project. ### What Blazor-specific files does Atlas index? Atlas indexes `.razor` components, C# files, and `.csproj` files. It builds its code index by AST declarations using tree-sitter, ensuring a deep understanding of Blazor SDK targets and component structures. ### How does Atlas ensure I don't accidentally change my Blazor codebase? Atlas employs several safety measures: it drafts a plan in a read-only plan agent, every tool call is permission-gated, and it computes a unified diff for every file edit, surfacing it for your approval before writing any changes to your Blazor files. ### Can Atlas help me add tests to my Blazor components? Yes, Atlas can add `bUnit` component tests to your Blazor application. It will then run `dotnet test` behind a permission prompt, allowing you to verify component behavior and ensure code quality. ### Does Atlas keep my Blazor code off third-party servers? Yes, Atlas can build its code index with local Ollama embeddings, keeping your Blazor code and proprietary information entirely off third-party servers, ensuring data privacy and security. ### How does Atlas handle Blazor package management? Atlas understands `NuGet` for package management. While exploring, it can identify `dotnet add package` commands and dependencies, helping you understand the external libraries used in your Blazor project. --- Canonical HTML: https://runatlas.sh/resources/stacks/onboard-to-an-unfamiliar-codebase-in-blazor Source of truth: aeo_pages row `/resources/stacks/onboard-to-an-unfamiliar-codebase-in-blazor` (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.