.NET Claude Kit — Make Claude Code a .NET 10 Expert

The Problem

Without the kit, Claude generates generic C#

Real patterns Claude produces without .NET-specific knowledge. Every one is a code review rejection.

VS

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

VS

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

VS

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

VS

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 = Uuid7.CreateVersion7(now)
    };
    return order;
}

TimeProvider + UUIDv7 (testable & deterministic)

VS

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

Your team's patterns. First try. Every time.

See what's inside

What's Inside

What ships in the kit

Four layers that turn Claude into a .NET specialist.

Architecture Advisor

15-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

Scaffolding

Generate features, entities, tests for all architectures

MCP Tool	Replaces	Without Kit	With Kit	Savings
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%
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%
detect_antipatterns	Manual code review	500+	Variable	76%
find_dead_code	Manual inspection	500+	Variable	76%
get_test_coverage_map	Manual test search	500+	Variable	76%

Read-only — no mutations Cross-project — solution-wide Cached — compiled once

Hero Feature

Architecture in 3 clicks

Answer 3 questions. Get a tailored architecture recommendation instantly.

1 Domain complexity?

2 Team size?

3 Expected lifetime?

Recommendation

Vertical Slice Architecture

Perfect for solo devs with simple CRUD apps. Minimal ceremony, feature-focused folders, and easy to evolve. When complexity grows, you can migrate individual slices to Clean Architecture boundaries.

Result updates live as you answer

See It in Action

Real examples, real results

Click a scenario to watch what happens when Claude has the .NET Claude Kit loaded.

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 · 94 tokens (vs ~1,100 without kit)

Get Started

Up and running in 5 minutes

Two commands to install. Pick a template. Start building.

1

Install the Kit

One command inside Claude Code — or clone manually.

2

Pick a Template

Copy the matching CLAUDE.md for your project type.

3

Start Building

Skills, agents, and MCP tools activate automatically.

terminal

## Step 1 — Install the plugin

> /install codewithmukesh/dotnet-claude-kit

## Step 2 — Copy a template into your project

$ cp templates/web-api/CLAUDE.md ./CLAUDE.md

## Step 3 — Launch Claude Code

$ claude ✓ dotnet-claude-kit loaded

View on GitHub

FAQ

Frequently asked questions

What is the .NET Claude Kit?

The .NET Claude Kit is an open-source companion for Claude Code that makes it an expert .NET developer. It includes 27 curated skills, 8 specialist agents, 15 Roslyn-powered MCP tools, and 5 project templates — all built for .NET 10 and C# 14. Think of it as a production-grade knowledge and action layer between Claude and your .NET project.

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

Without the kit, Claude generates generic C# — DateTime.Now instead of TimeProvider, repository wrappers over EF Core, in-memory test fakes instead of Testcontainers, and reads entire files burning 500–2000 tokens. With the kit, Claude generates idiomatic .NET 10 code on the first try, uses Roslyn MCP tools for 10x token savings, and follows modern patterns like Result types, HybridCache, and Polly v8.

Which .NET project types are supported?

The kit includes 5 drop-in CLAUDE.md templates: Web API (with Vertical Slice, Clean Architecture, or DDD options), Modular Monolith, Blazor App (Server/WASM/Auto), Worker Service, and Class Library. Each template is pre-configured with the right skills, agents, and conventions for that project type.

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

The agents are: dotnet-architect (project structure, scaffolding), api-designer (endpoints, OpenAPI, versioning), ef-core-specialist (database, migrations, queries), test-engineer (xUnit v3, Testcontainers), security-auditor (auth, OWASP), performance-analyst (benchmarks, caching), devops-engineer (Docker, CI/CD, Aspire), and code-reviewer (multi-dimensional PR review). Claude automatically routes your query to the right specialist based on intent.

What are MCP tools and why do they matter?

MCP (Model Context Protocol) tools let Claude query your codebase semantically via Roslyn instead of reading raw files. For example, find_symbol locates a type definition in 30–50 tokens instead of grepping through files at 500+ tokens. The 15 tools cover symbol resolution, type hierarchies, project graphs, anti-pattern detection, dead code analysis, and test coverage mapping — saving roughly 10x tokens on navigation.

How does the architecture advisor work?

When you start a new project, the dotnet-architect agent runs a structured 15-question questionnaire covering domain complexity, team size, project lifetime, compliance needs, and more. Based on your answers, it recommends one of four architectures: Vertical Slice Architecture, Clean Architecture, Domain-Driven Design, or Modular Monolith — with clear rationale and evolution paths when your project outgrows its current architecture.

Is the kit compatible with existing projects?

Yes. Copy the matching template CLAUDE.md into your project root, adjust the placeholders, and start Claude Code. The convention-learner skill automatically detects your existing patterns (naming, folder structure, modifiers) and enforces them in new code and reviews. No migration or refactoring required.

How do I install the .NET Claude Kit?

Two options: (1) Via Claude Code plugin marketplace — run /plugin marketplace add codewithmukesh/dotnet-claude-kit then /plugin install. (2) Manual — clone the repo, copy a template CLAUDE.md into your project, and customize it. Full instructions are in the GitHub README.

Is the .NET Claude Kit free and open source?

Yes, 100% free and MIT licensed. The entire kit — skills, agents, templates, MCP server, hooks, and knowledge base — is open source on GitHub. Community contributions are welcome.

How often is the kit updated?

The kit is a living project that evolves with .NET releases. Knowledge documents are updated per .NET release, skills are refined based on community feedback, and new patterns are added as the ecosystem evolves. The current version is 0.4.0 with 4 major component categories: skills, agents, MCP tools, and automation hooks.

Your next `claude` session could generate production-ready .NET 10

27 skills. 8 agents. 15 MCP tools. 5 templates. Free, open source, MIT licensed.

Get the Kit on GitHub Subscribe for Updates

Join 8,200+ developers on the newsletter

Make Claude Code a .NET 10 Expert

Without the kit, Claude generates generic C#

What ships in the kit

Architecture Advisor

Vertical Slice

Clean Architecture

DDD

Project Structure

Scaffolding

Minimal API

API Versioning

Authentication

Error Handling

Resilience

EF Core

Caching

Messaging

Configuration

DI

Docker

CI/CD

Aspire

Logging

Migration

Modern C#

Testing

Code Review

Convention Learner

Workflow Mastery

Project Setup

dotnet-architect

api-designer

ef-core-specialist

test-engineer

security-auditor

performance-analyst

devops-engineer

code-reviewer

Web API

Modular Monolith

Blazor App

Worker Service

Class Library

Architecture in 3 clicks

Real examples, real results

Up and running in 5 minutes

Install the Kit

Pick a Template

Start Building

Frequently asked questions

Your next claude session could generate production-ready .NET 10

Stay ahead in .NET

Make Claude Code a
.NET 10 Expert

Your next `claude` session could generate production-ready .NET 10