How does Atlas handle .NET project structures like .sln and .csproj?

Atlas is designed to operate within a .NET solution, automatically recognizing `.sln` and `.csproj` files. It builds its code index using AST declarations via tree-sitter, understanding your project references, minimal APIs, and DI container setup.

What .NET specific tools does Atlas use for code formatting?

Atlas leverages the standard .NET toolchain for code formatting. When reviewing or proposing changes, it can utilize `dotnet format` to ensure adherence to your project's coding style guidelines.

How does Atlas ensure safety when modifying .NET code?

Atlas employs a multi-stage safety protocol. It drafts plans in a read-only agent, asks for permission before switching to a build agent, and computes a unified diff for every file edit, requiring explicit approval before writing any changes to your .NET codebase.

Can Atlas review changes to ASP.NET Core minimal APIs?

Yes, Atlas is fully capable of reading and understanding your ASP.NET Core minimal APIs. Its AST-based indexing allows it to comprehend the structure and dependencies within `Program.cs` and other relevant files.

How does Atlas find references for C# methods across a .NET solution?

Atlas uses its `lsp` tool, which connects to Model Context Protocol servers, to perform `findReferences` operations. This allows it to accurately locate all invocations of a C# method or property across multiple `.csproj` files within your .NET solution.

What kind of bugs can Atlas catch that a human might miss in a .NET PR?

Atlas excels at catching contextual bugs that a line-by-line review might miss. This includes broken callers from changed C# signatures (via `lsp`), missed updates to old constant names or feature flags (via `grep`), and issues arising from incomplete context outside diff hunks (via `read`).

Does Atlas keep my .NET code private during review?

Yes, Atlas prioritizes code privacy. It can build its code index with local Ollama embeddings, ensuring that your sensitive .NET codebase remains on your local machine and off third-party servers.

Review a Pull Request in .NET with Atlas in 2026

In 2026, .NET developers leverage Atlas to review pull requests by understanding code context beyond simple diffs, ensuring changes integrate correctly with ASP.NET Core applications, and verifying behavior using `xUnit via dotnet test` and `dotnet format`.

How Atlas Fetches .NET Pull Request Changes

Atlas begins a .NET pull request review by fetching the specific branch and generating a raw diff, much like a human developer would in 2026. This initial step uses the `bash` tool to interact with the underlying Git repository, ensuring all changes are accurately captured.

To initiate a review, Atlas first uses its `bash` tool to execute standard Git commands, such as `git fetch origin <branch-name>` and `git diff <base-branch> <feature-branch>`. This process provides Atlas with the complete set of modified files and the raw patch data for the .NET codebase. Atlas's VCS layer exposes `status`, `diff`, `diffRaw`, and `commits` over the same Git data, allowing it to precisely identify every change within your `.sln` or `.csproj` solution. This foundational step ensures that Atlas has the exact same view of the proposed changes as any developer working with the .NET SDK.

Gaining Full Context for .NET Codebase Changes

A critical aspect of reviewing .NET code in 2026 is understanding the full context surrounding a change, not just the diff hunks. Atlas achieves this by using its `read` tool to pull entire `.cs` files, providing a comprehensive view of the code.

Unlike a line-by-line diff that might obscure the broader impact of a change, Atlas's `read` tool retrieves the complete content of any modified `.cs` file. This capability is vital for .NET projects, especially when dealing with complex dependency injection setups in ASP.NET Core or intricate minimal APIs. By reading the full files, Atlas can identify how a change in one part of a class, such as a new method in `Program.cs` or a modification to a service registration, affects other parts of the file or related components that might not appear in the immediate diff hunk. This prevents bugs that a limited view would miss.

Validating .NET Signature Updates with LSP

In 2026, modifying a C# method signature in a .NET project requires careful validation to prevent breaking callers. Atlas employs its `lsp` tool's `findReferences` operation to automatically check every invocation of a changed signature, even those outside the immediate diff.

When a developer alters a method signature within a `.cs` file, such as changing parameters in an ASP.NET Core controller action or a utility method, Atlas's `lsp` tool becomes indispensable. It leverages the Language Server Protocol to perform a `findReferences` operation on the modified signature. This ensures that every caller throughout the entire .NET solution, across multiple `.csproj` files, is identified and checked for compatibility. This proactive validation catches potential compilation errors or runtime issues that a human reviewer might overlook, especially in large .NET codebases where a single signature change could impact dozens of files.

Detecting Missed .NET Updates with Grep

Atlas uses its `grep` tool to identify instances where a .NET code change should have updated related patterns but did not, a common source of bugs in 2026. This includes searching for old constant names, stale copies of code, or feature flags.

After analyzing the primary changes, Atlas's `grep` tool scans the .NET codebase for specific patterns that should have been updated in conjunction with the pull request. For example, if a constant defined in a `Constants.cs` file was renamed, Atlas can `grep` for the old name to ensure all references are updated. Similarly, it can detect stale copies of code that should have been refactored or removed, or verify that feature flags in `appsettings.json` or C# code are consistently applied. This targeted search helps maintain consistency and prevents subtle bugs that arise from incomplete refactoring or overlooked dependencies within the .NET project.

Automated .NET Test Execution with xUnit via dotnet test

To ensure the integrity of a .NET pull request, Atlas automatically runs the project's tests using `xUnit via dotnet test`, a standard practice in 2026. This step provides immediate feedback on the functional correctness of the proposed changes.

Atlas executes the full suite of unit and integration tests for the .NET solution by invoking the `bash` tool to run `dotnet test`. This command, configured for `xUnit`, compiles and runs all tests defined within the `.csproj` files. Atlas then captures the output, reporting any failures or warnings. This automated testing is crucial for verifying that new features or bug fixes do not introduce regressions and that existing functionality remains robust. The findings from `xUnit via dotnet test` are then incorporated into Atlas's review summary, providing concrete evidence of the change's impact.

Atlas's Safety and Approval for .NET Code Changes

Atlas prioritizes safety in 2026 by drafting a plan in a read-only agent and requiring explicit approval for all .NET code modifications. Every proposed edit is presented as a unified diff, ensuring transparency and control for the developer.

Before Atlas makes any changes to your .NET codebase, it operates in a read-only plan agent to draft its strategy. This plan is presented to the developer for review and approval. Once approved, Atlas switches to a build agent, but even then, every file edit is computed as a unified diff and surfaced for explicit approval before it is written to disk. This permission-gated approach, combined with the ability to snapshot file changes as Git patches for rollback, provides a robust safety net. Developers can confidently review Atlas's suggestions for their ASP.NET Core applications, knowing they have full control over every modification, from adding an endpoint to an xUnit test.

Step by step

01Fetch the pull request branch and produce the raw diff using Atlas's `bash` tool, leveraging `git fetch` and `git diff` commands for your .NET solution.
02Read the full changed `.cs` files, not just the hunks, using Atlas's `read` tool to gain complete context around modifications in your .NET project.
03For every changed C# function signature, run Atlas's `lsp` tool's `findReferences` operation to check all callers across your .NET codebase, ensuring no breaking changes.
04Use Atlas's `grep` tool to search for patterns the change should have updated but did not, such as old constant names in `.cs` files or stale feature flags in `appsettings.json`.
05Run the comprehensive test suite using Atlas's `bash` tool to execute `xUnit via dotnet test`, verifying the functional correctness of the .NET changes.
06Atlas reports all findings as a `todowrite` list, ordered by severity, summarizing the review of the .NET pull request.
07Review Atlas's proposed changes and unified diff for your .NET files, then approve or reject modifications before they are written to disk.

Frequently asked questions

How does Atlas handle .NET project structures like .sln and .csproj?: Atlas is designed to operate within a .NET solution, automatically recognizing `.sln` and `.csproj` files. It builds its code index using AST declarations via tree-sitter, understanding your project references, minimal APIs, and DI container setup.
What .NET specific tools does Atlas use for code formatting?: Atlas leverages the standard .NET toolchain for code formatting. When reviewing or proposing changes, it can utilize `dotnet format` to ensure adherence to your project's coding style guidelines.
How does Atlas ensure safety when modifying .NET code?: Atlas employs a multi-stage safety protocol. It drafts plans in a read-only agent, asks for permission before switching to a build agent, and computes a unified diff for every file edit, requiring explicit approval before writing any changes to your .NET codebase.
Can Atlas review changes to ASP.NET Core minimal APIs?: Yes, Atlas is fully capable of reading and understanding your ASP.NET Core minimal APIs. Its AST-based indexing allows it to comprehend the structure and dependencies within `Program.cs` and other relevant files.
How does Atlas find references for C# methods across a .NET solution?: Atlas uses its `lsp` tool, which connects to Model Context Protocol servers, to perform `findReferences` operations. This allows it to accurately locate all invocations of a C# method or property across multiple `.csproj` files within your .NET solution.
What kind of bugs can Atlas catch that a human might miss in a .NET PR?: Atlas excels at catching contextual bugs that a line-by-line review might miss. This includes broken callers from changed C# signatures (via `lsp`), missed updates to old constant names or feature flags (via `grep`), and issues arising from incomplete context outside diff hunks (via `read`).
Does Atlas keep my .NET code private during review?: Yes, Atlas prioritizes code privacy. It can build its code index with local Ollama embeddings, ensuring that your sensitive .NET codebase remains on your local machine and off third-party servers.

Try Atlas in your terminal

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

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

Atlas for .NET: Your AI Coding Agent in 2026

Atlas empowers .NET developers in 2026 with a terminal-native AI coding agent. Securely integrate Atlas with ASP.NET Core for web APIs and services, leveraging local embeddings and robust safety features for efficient

Automate GitHub Issue and Pull Request Triage in .NET with Atlas in 2026

Streamline GitHub issue and pull request triage for your .NET projects using Atlas in 2026. Integrate with GitHub Actions, leverage real .NET tools like NuGet and dotnet test, and ensure secure, permission-gated

Add a Regression Test for a Bug Fix in .NET with Atlas in 2026

Lock in .NET bug fixes with robust regression tests using Atlas. Learn how to write failing xUnit tests, apply fixes, and verify with `dotnet test` for ASP.NET Core projects in 2026.

Self-review your working diff before committing in .NET with Atlas in 2026

In 2026, .NET developers use Atlas to self-review uncommitted diffs, catching mistakes before CI. Leverage `dotnet test`, `dotnet format`, and `NuGet` with AI assistance.

Document a .NET Module with a README using Atlas in 2026

Atlas helps .NET developers in 2026 create accurate README documentation directly from source code. It uses the .NET SDK and LSP to describe module APIs, ensuring docs reflect current implementation.

Onboard to an Unfamiliar .NET Codebase with Atlas in 2026

Rapidly build a working mental model of any .NET repository in 2026 using Atlas. Leverage semantic search, NuGet package analysis, and xUnit test exploration to understand code without reading every file.

Extract a Shared Helper from Duplicated .NET Code with Atlas in 2026

Refactor duplicated logic in your .NET codebase by extracting shared helpers with Atlas. Leverage semantic search, automated file creation, and atomic patch application for a streamlined workflow in 2026.

Browse this resource hub