What is the .NET Claude Kit?

The .NET Claude Kit is a free, open-source plugin I built for Claude Code. It teaches Claude how modern .NET code should be written. It includes 47 skills, 10 specialist agents, 16 slash commands, 10 rules that you can copy into your project, 22 Roslyn-based MCP tools, 7 automation hooks, and 5 project templates, all built for .NET 10 and C# 14. You can think of it as a layer of .NET knowledge and tools that sits between Claude and your project.

How does it differ from using Claude Code without the kit?

Without the kit, Claude often writes generic C#. For example, it uses DateTime.Now instead of TimeProvider, wraps EF Core in repository classes, uses in-memory fakes in tests instead of Testcontainers, and reads entire files to find one method, which costs 500 to 2,000 tokens each time. With the kit, Claude follows current .NET 10 patterns like the Result pattern, IEndpointGroup auto-discovery, HybridCache, Wolverine for messaging, and Polly v8. It also uses the Roslyn MCP tools to look up code, which needs far fewer tokens than reading whole files.

Which .NET project types are supported?

The kit comes with 5 CLAUDE.md templates: Web API (with Vertical Slice, Clean Architecture, or DDD options), Modular Monolith, Blazor App (Server, WASM, or Auto), Worker Service, and Class Library. Each template is already set up with the right skills, agents, and conventions for that type of project. You can also run /dotnet-init, which detects your project and generates a CLAUDE.md file for you.

What are the 10 specialist agents and how do they work?

The agents are dotnet-architect (project structure and scaffolding), api-designer (endpoints, OpenAPI, and versioning), ef-core-specialist (database, migrations, and queries), test-engineer (xUnit v3 and Testcontainers), security-auditor (authentication and OWASP), performance-analyst (benchmarks and caching), devops-engineer (Docker, CI/CD, and Aspire), code-reviewer (pull request reviews), build-error-resolver (fixes build errors in a loop until the build passes), and refactor-cleaner (removes dead code, working in a separate git worktree). Claude picks the right agent based on what you ask for. Five of them (code-reviewer, dotnet-architect, security-auditor, performance-analyst, and test-engineer) have project memory, so they remember your conventions across sessions. The code-reviewer agent is also limited to read-only tools, so it can't change your code.

What are MCP tools and why do they matter?

MCP (Model Context Protocol) tools let Claude ask questions about your code through Roslyn instead of reading raw files. For example, find_symbol finds a type definition in about 30 to 50 tokens, where searching through files would cost 500 tokens or more, and get_symbol_source reads just one method instead of the whole file. The 22 tools cover finding symbols, type hierarchies, project graphs, anti-pattern detection, dead code, NuGet packages, endpoint maps, DI registrations, stack trace resolution, and change impact analysis. Every tool that returns a list also tells you when the results were cut short, so a single query can't fill up Claude's context window.

How does the architecture advisor work?

When you start a new project, the dotnet-architect agent asks you 16 questions about things like how complex your domain is, how big your team is, how long the project will live, and any compliance needs. Based on your answers, it recommends one of four architectures: Vertical Slice Architecture, Clean Architecture, DDD with Clean Architecture, or a Modular Monolith. It also explains why, and how you can move to a different architecture later if your project outgrows it.

What are slash commands and how do they work?

The kit includes 16 slash commands, such as /dotnet-init, /scaffold, /verify, /tdd, /code-review, /build-fix, /health-check, /security-scan, /de-sloppify, /outdated, and /arch-check. The /outdated command finds stale packages, known vulnerabilities, and packages that moved to a commercial license, like MediatR 13+ and MassTransit 9+. The /arch-check command checks that your code follows your architecture, looking at dependency direction, layer violations, module boundaries, and cycles. Each command brings in the right skills and agents for you. For example, /scaffold generates a complete feature with the Result pattern, validation, OpenAPI metadata, pagination, CancellationToken support, and tests, and checks it against a 9-point checklist.

Is the kit compatible with existing projects?

Yes. Run /dotnet-init in your project folder. It detects your solution, looks at your project SDKs and tech stack, and generates a CLAUDE.md file that fits your project. You can also copy one of the templates by hand if you prefer. The convention-learner skill picks up the patterns you already use, like naming, folder structure, and modifiers, and follows them in new code and reviews. You don't need to migrate or refactor anything first.

How do I install the .NET Claude Kit?

There are two ways. (1) As a Claude Code plugin: run 'dotnet tool install -g CWM.RoslynNavigator' to install the MCP server, and then inside Claude Code run '/plugin marketplace add codewithmukesh/dotnet-claude-kit' followed by '/plugin install dotnet-claude-kit'. (2) Manually: clone the repository and start Claude Code with 'claude --plugin-dir ./dotnet-claude-kit'. The full instructions are in the GitHub README.

Does it work with other AI coding tools?

Yes. The kit is built for Claude Code, but it also supports Cursor (through .cursor/rules/), Codex CLI (through .codex/AGENTS.md), and OpenCode. The core skills, knowledge base, and MCP tools work across all of them.

Is the .NET Claude Kit free and open source?

Yes, it is completely free and MIT licensed. Everything in the kit, including the skills, agents, commands, rules, templates, hooks, MCP server, and knowledge base, is open source on GitHub. Contributions are always welcome.

How often is the kit updated?

I keep updating the kit as .NET changes. Package recommendations are checked against NuGet, the security guidance follows the OWASP Top 10:2025, and there is a .NET 11 preview section so the guidance is ready before the November release. The hooks are tested on both Windows and Linux in CI. The current version is 0.12.0.

Open source -- stars on GitHub →

Teach Claude Code modern .NET 10

The .NET Claude Kit is a free, open-source plugin I built for Claude Code. It comes with 47 skills, 10 specialist agents, 16 slash commands, and 22 Roslyn MCP tools, so that Claude writes code that follows current .NET 10 and C# 14 practices.

Get the kit on GitHub ↗ Quick-start guide →

v0.12.0
·
MIT licensed
·
Free and open source
·
.NET 10 / C# 14

claude code session

~/CWM.WebApi

An example session in a .NET 10 Web API project

What is in the kit

Skills

47

Guides for .NET topics
Agents

10

Picked based on your task
Commands

16

/scaffold · /tdd · /verify
MCP tools

22

Built on Roslyn

The problem

5 patterns · before / after

What Claude writes without the kit

Out of the box, Claude Code doesn't know the conventions of modern .NET, so it often falls back to older patterns. Here are five common examples, and what the same code looks like once the kit is installed. Pick a tab to compare them side by side.

12345678910111213

try
{
    var product = await _repository
        .GetByIdAsync(id);
    if (product == null)
        throw new NotFoundException();
    return Ok(product);
}
catch (Exception ex)
{
    _logger.LogError(ex, "Error");
    return StatusCode(500);
}

Exceptions for control flow

Repository wraps EF Core

123456789101112

public async Task<Result<ProductDto>>
    Handle(GetProductQuery q, CancellationToken ct)
{
    var product = await db.Products
        .Where(p => p.Id == q.Id)
        .Select(p => new ProductDto(p))
        .FirstOrDefaultAsync(ct);

    return product is null
        ? Result.NotFound("Product not found")
        : Result.Ok(product);
}

Result pattern + DbContext + CancellationToken

1234567891011

var options = new DbContextOptionsBuilder()
    .UseInMemoryDatabase("TestDb")
    .Options;

var mockRepo = new Mock<IProductRepo>();
mockRepo.Setup(x => x.GetAll())
    .ReturnsAsync(testProducts);

// Hides real DB bugs, no constraint
// checking, no query translation,
// false positives everywhere

InMemoryDatabase hides real bugs

Mocks bypass real behavior

123456789101112

public class CreateProductTests(
    AppFactory factory
) : IClassFixture<AppFactory>
{
    [Fact]
    public async Task Creates_Product()
    {
        var client = factory.CreateClient();
        var r = await client.PostAsJsonAsync(
            "/api/products", dto);
    }
}

WebApplicationFactory + Testcontainers

1234567891011

var cached = await _cache
    .GetStringAsync(key);
if (cached != null)
    return JsonSerializer
        .Deserialize<Product>(cached);

var product = await db.Products
    .FindAsync(id);
await _cache.SetStringAsync(key,
    JsonSerializer.Serialize(product),
    new DistributedCacheEntryOptions { ... });

12 lines of manual serialize/deserialize

No stampede protection

12345678910

var product = await cache
    .GetOrCreateAsync(
        $"products:{id}",
        async ct => await db.Products
            .FindAsync([id], ct),
        tags: ["products"]
    );

// HybridCache: L1 memory + L2 distributed
// Tag invalidation, stampede protection

HybridCache one-liner with tag invalidation

1234567891011121314

public Order CreateOrder(Cart cart)
{
    var order = new Order
    {
        CreatedAt = DateTime.Now,
        ExpiresAt = DateTime.UtcNow
            .AddMinutes(30),
        Id = Guid.NewGuid()
    };

    // Untestable - hardcoded time,
    // mixed Now/UtcNow, non-deterministic ID
    return order;
}

DateTime.Now is untestable

Mixed Now / UtcNow in same method

1234567891011121314

public Order CreateOrder(
    Cart cart,
    TimeProvider time)
{
    var now = time.GetUtcNow();
    var order = new Order
    {
        CreatedAt = now,
        ExpiresAt = now.Add(
            TimeSpan.FromMinutes(30)),
        Id = Guid.CreateVersion7(now)
    };
    return order;
}

TimeProvider makes time testable, plus UUIDv7 IDs

123456789101112131415

public async Task<Result> ChargeAsync()
{
    for (var i = 0; i < 3; i++)
    {
        try
        {
            return await _httpClient
                .PostAsync(url, content);
        }
        catch
        {
            await Task.Delay(1000);
        }
    }
}

Hand-rolled retry with fixed delay

No circuit breaker or jitter

1234567891011121314

builder.Services
    .AddHttpClient<IPaymentGateway,
        StripeGateway>()
    .AddResilienceHandler("payments",
        b => b
        .AddRetry(new()
        {
            MaxRetryAttempts = 3,
            BackoffType =
                DelayBackoffType.Exponential,
            UseJitter = true
        })
        .AddCircuitBreaker()
        .AddTimeout(TimeSpan.FromSeconds(5)));

Polly v8 pipeline with jitter + circuit breaker

The kit teaches Claude these patterns, so you spend less time correcting its code in review.

See what is inside the kit

What's inside

Skills · Agents · MCP · Templates

The four parts of the kit

The kit is made up of four parts. Skills hold the .NET knowledge, agents handle specific kinds of tasks, the MCP tools let Claude look up your code without reading whole files, and the templates give Claude your project's conventions from the very first session.

Architecture Advisor

16-question questionnaire maps to VSA, CA, DDD, or Modular Monolith

Vertical Slice

Feature folders, endpoint grouping, single-file features

Clean Architecture

4-project layout, dependency inversion, proper layers

DDD

Aggregates, value objects, domain events, strongly-typed IDs

Project Structure

.slnx format, Directory.Build.props, central package management

Arch Check

/arch-check - dependency direction, layer violations, boundary leaks, cycles

MCP Tool	Replaces	Without Kit	With Kit	Savings
get_symbol_source	Reading the whole file for one method	500+	Variable	76%
get_file_outline	Reading full file contents	500+	Variable	76%
get_nuget_packages	.csproj + props parsing	500+	Variable	76%
get_endpoint_map	Grepping for MapGet/MapPost	500+	Variable	76%
get_di_registrations	Reading Program.cs + extensions	500+	Variable	76%
find_symbol	Grep all files	500+	30–50	92%
find_references	Manual grep	500+	50–150	80%
find_implementations	Search : IInterface	500+	30–80	89%
find_callers	Method name grep	500+	40–100	86%
find_overrides	Search override keyword	500+	30–80	89%
get_type_hierarchy	Read multiple files	500+	40–100	86%
get_project_graph	.csproj parsing	500+	50–200	75%
get_public_api	Read entire file	500+	~100	80%
get_symbol_detail	Read entire source file	500+	~80	84%
get_diagnostics	dotnet build parsing	500+	Variable	76%
detect_antipatterns	Manual code review	500+	Variable	76%
find_dead_code	Manual inspection	500+	Variable	76%
detect_circular_dependencies	Manual reference tracing	500+	Variable	76%
get_dependency_graph	Reading & tracing files	500+	Variable	76%
get_test_coverage_map	Manual test search	500+	Variable	76%
resolve_stack_trace	Tracing exception frames by hand	500+	Variable	76%
analyze_change_impact	Finding everything a change breaks	500+	Variable	76%

Read-only - they never change your code Solution-wide - they work across all your projects Cached - your solution is compiled once Bounded - every list tells you when it was truncated

Architecture advisor

Try it · 3 questions

Pick an architecture for your project

Choosing an architecture at the start of a project is not easy, so the kit includes an advisor for it. Answer the three questions below to get a quick recommendation. The full advisor inside Claude Code asks 16 questions and also considers things like compliance needs, integrations, and how your team is spread out.

Pick three answers

tell me about your project

1 Domain complexity?

2 Team size?

3 Expected lifetime?

Recommendation

Vertical Slice Architecture

A good fit for a solo developer building a simple CRUD app. There is very little ceremony, your code is grouped by feature, and it is easy to change later. If the app grows more complex, you can move individual slices to Clean Architecture boundaries.

The recommendation updates as you change your answers

See it in action

7 example scenarios

Common tasks with the kit

Click on a scenario to see how Claude handles a common .NET task when the kit is installed. The agents and MCP tools are the real ones from the kit, and the output is a simplified example of what you would see.

claude code

$ claude "Add a CRUD endpoint for products"

Routing to api-designer agent...

Scanning project structure via MCP...

+ Features/Products/CreateProduct.cs

+ Features/Products/GetProduct.cs

+ Features/Products/ProductValidator.cs

+ Persistence/ProductConfiguration.cs

+ Tests/Products/CreateProductTests.cs

Done. 5 files created, including tests

Quick start

3 steps

Installing the kit in three steps

First, you install the Roslyn MCP server as a .NET tool. Then you add the plugin from inside Claude Code, and finally you run /dotnet-init in your project so the kit can generate a CLAUDE.md file for it.

01

Install the kit

Install it as a plugin from inside Claude Code, or clone the repository and load it manually.
02

Set up your project

Run /dotnet-init to generate a CLAUDE.md, or copy the template that matches your project type.
03

Start building

From here, Claude picks up the skills, agents, and MCP tools on its own as you work.

terminal

## Step 1 - Install the Roslyn MCP server

$ dotnet tool install -g CWM.RoslynNavigator

## Step 2 - Install the plugin (inside Claude Code)

> /plugin marketplace add codewithmukesh/dotnet-claude-kit

> /plugin install dotnet-claude-kit

## Step 3 - Init your project

> /dotnet-init ✓ CLAUDE.md generated

Read the guide 25 min read

How I Use dotnet-claude-kit: Making Claude Code Write Senior-Level .NET

If you want more than the install commands, this article walks through what Claude Code gets wrong on .NET out of the box, how each skill, agent, and MCP tool helps, and the workflow I follow day to day.

View on GitHub ↗

FAQ

12 questions

Q01 What is the .NET Claude Kit?

The .NET Claude Kit is a free, open-source plugin I built for Claude Code. It teaches Claude how modern .NET code should be written. It includes 47 skills, 10 specialist agents, 16 slash commands, 10 rules that you can copy into your project, 22 Roslyn-based MCP tools, 7 automation hooks, and 5 project templates, all built for .NET 10 and C# 14. You can think of it as a layer of .NET knowledge and tools that sits between Claude and your project.
Q02 How does it differ from using Claude Code without the kit?

Without the kit, Claude often writes generic C#. For example, it uses DateTime.Now instead of TimeProvider, wraps EF Core in repository classes, uses in-memory fakes in tests instead of Testcontainers, and reads entire files to find one method, which costs 500 to 2,000 tokens each time. With the kit, Claude follows current .NET 10 patterns like the Result pattern, IEndpointGroup auto-discovery, HybridCache, Wolverine for messaging, and Polly v8. It also uses the Roslyn MCP tools to look up code, which needs far fewer tokens than reading whole files.
Q03 Which .NET project types are supported?

The kit comes with 5 CLAUDE.md templates: Web API (with Vertical Slice, Clean Architecture, or DDD options), Modular Monolith, Blazor App (Server, WASM, or Auto), Worker Service, and Class Library. Each template is already set up with the right skills, agents, and conventions for that type of project. You can also run /dotnet-init, which detects your project and generates a CLAUDE.md file for you.
Q04 What are the 10 specialist agents and how do they work?

The agents are dotnet-architect (project structure and scaffolding), api-designer (endpoints, OpenAPI, and versioning), ef-core-specialist (database, migrations, and queries), test-engineer (xUnit v3 and Testcontainers), security-auditor (authentication and OWASP), performance-analyst (benchmarks and caching), devops-engineer (Docker, CI/CD, and Aspire), code-reviewer (pull request reviews), build-error-resolver (fixes build errors in a loop until the build passes), and refactor-cleaner (removes dead code, working in a separate git worktree). Claude picks the right agent based on what you ask for. Five of them (code-reviewer, dotnet-architect, security-auditor, performance-analyst, and test-engineer) have project memory, so they remember your conventions across sessions. The code-reviewer agent is also limited to read-only tools, so it can't change your code.
Q05 What are MCP tools and why do they matter?

MCP (Model Context Protocol) tools let Claude ask questions about your code through Roslyn instead of reading raw files. For example, find_symbol finds a type definition in about 30 to 50 tokens, where searching through files would cost 500 tokens or more, and get_symbol_source reads just one method instead of the whole file. The 22 tools cover finding symbols, type hierarchies, project graphs, anti-pattern detection, dead code, NuGet packages, endpoint maps, DI registrations, stack trace resolution, and change impact analysis. Every tool that returns a list also tells you when the results were cut short, so a single query can't fill up Claude's context window.
Q06 How does the architecture advisor work?

When you start a new project, the dotnet-architect agent asks you 16 questions about things like how complex your domain is, how big your team is, how long the project will live, and any compliance needs. Based on your answers, it recommends one of four architectures: Vertical Slice Architecture, Clean Architecture, DDD with Clean Architecture, or a Modular Monolith. It also explains why, and how you can move to a different architecture later if your project outgrows it.
Q07 What are slash commands and how do they work?

The kit includes 16 slash commands, such as /dotnet-init, /scaffold, /verify, /tdd, /code-review, /build-fix, /health-check, /security-scan, /de-sloppify, /outdated, and /arch-check. The /outdated command finds stale packages, known vulnerabilities, and packages that moved to a commercial license, like MediatR 13+ and MassTransit 9+. The /arch-check command checks that your code follows your architecture, looking at dependency direction, layer violations, module boundaries, and cycles. Each command brings in the right skills and agents for you. For example, /scaffold generates a complete feature with the Result pattern, validation, OpenAPI metadata, pagination, CancellationToken support, and tests, and checks it against a 9-point checklist.
Q08 Is the kit compatible with existing projects?

Yes. Run /dotnet-init in your project folder. It detects your solution, looks at your project SDKs and tech stack, and generates a CLAUDE.md file that fits your project. You can also copy one of the templates by hand if you prefer. The convention-learner skill picks up the patterns you already use, like naming, folder structure, and modifiers, and follows them in new code and reviews. You don't need to migrate or refactor anything first.
Q09 How do I install the .NET Claude Kit?

There are two ways. (1) As a Claude Code plugin: run 'dotnet tool install -g CWM.RoslynNavigator' to install the MCP server, and then inside Claude Code run '/plugin marketplace add codewithmukesh/dotnet-claude-kit' followed by '/plugin install dotnet-claude-kit'. (2) Manually: clone the repository and start Claude Code with 'claude --plugin-dir ./dotnet-claude-kit'. The full instructions are in the GitHub README.
Q10 Does it work with other AI coding tools?

Yes. The kit is built for Claude Code, but it also supports Cursor (through .cursor/rules/), Codex CLI (through .codex/AGENTS.md), and OpenCode. The core skills, knowledge base, and MCP tools work across all of them.
Q11 Is the .NET Claude Kit free and open source?

Yes, it is completely free and MIT licensed. Everything in the kit, including the skills, agents, commands, rules, templates, hooks, MCP server, and knowledge base, is open source on GitHub. Contributions are always welcome.
Q12 How often is the kit updated?

I keep updating the kit as .NET changes. Package recommendations are checked against NuGet, the security guidance follows the OWASP Top 10:2025, and there is a .NET 11 preview section so the guidance is ready before the November release. The hooks are tested on both Windows and Linux in CI. The current version is 0.12.0.

Common questions about the kit · Last updated for v0.12.0

Try it in your next session

Use the kit in your next `claude` session on a .NET 10 project

The kit comes with 47 skills, 10 agents, 16 commands, 22 MCP tools, and 5 templates. It is free, open source, and MIT licensed.

Get the kit on GitHub ↗ Subscribe for updates

Join 9,735 developers on the newsletter

What Claude writes without the kit

The four parts of the kit

Architecture Advisor

Vertical Slice

Clean Architecture

DDD

Project Structure

Arch Check

Minimal API

API Versioning

Authentication

Error Handling

Resilience

EF Core

Caching

Messaging

Configuration

DI

Modern C#

Docker

CI/CD

Aspire

Logging

Testing

Code Review

Verify

Health Check

Security Scan

De-sloppify

Outdated Packages

Scaffold

Dotnet Init

Convention Learner

Migrate

Workflow Mastery

Instinct System

dotnet-architect

api-designer

ef-core-specialist

test-engineer

security-auditor

performance-analyst

devops-engineer

code-reviewer

build-error-resolver

refactor-cleaner

Web API

Modular Monolith

Blazor App

Worker Service

Class Library

Pick an architecture for your project

tell me about your project

Common tasks with the kit

Installing the kit in three steps

Install the kit

Set up your project

Start building

How I Use dotnet-claude-kit: Making Claude Code Write Senior-Level .NET

Use the kit in your next claude session on a .NET 10 project

stay ahead in .NET

Cookies, but only the useful ones.

Use the kit in your next `claude` session on a .NET 10 project