v0.7.0 - Open Source & Free

Make Claude Code a
.NET 10 Expert

Open-source Claude Code companion with 47 skills, 10 specialist agents, 16 slash commands, and 15 Roslyn MCP tools - so Claude generates production-ready .NET 10 / C# 14 code on the first try.

Get the Kit on GitHub Quick Start Guide

Skills

Agents

Commands

MCP Tools

claude code

The Problem

Without the kit, Claude generates generic C#

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

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

TimeProvider + UUIDv7 (testable & deterministic)

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

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

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.

Install the Kit

One command inside Claude Code - or clone manually.

Pick a Template

Copy the matching CLAUDE.md for your project type.

Start Building

Skills, agents, and MCP tools activate automatically.

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

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 47 curated skills, 10 specialist agents, 16 slash commands, 10 always-loaded rules, 15 Roslyn-powered MCP tools, 7 automation hooks, 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, IEndpointGroup auto-discovery, HybridCache, Wolverine-first messaging, 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. Or just run /dotnet-init to auto-detect and generate a customized CLAUDE.md.

What are the 10 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), code-reviewer (multi-dimensional PR review), build-error-resolver (autonomous build-fix loops), and refactor-cleaner (dead code removal, de-sloppify). 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, circular dependency detection, dead code analysis, dependency graph visualization, 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.

What are slash commands and how do they work?

The kit includes 16 slash commands like /dotnet-init, /scaffold, /verify, /tdd, /code-review, /build-fix, /health-check, /security-scan, /de-sloppify, and more. Each command orchestrates the right skills and agents automatically. For example, /scaffold generates a complete feature with Result pattern, validation, OpenAPI metadata, pagination, CancellationToken, and tests - enforcing a 9-point quality checklist across all 4 architecture styles.

Is the kit compatible with existing projects?

Yes. Run /dotnet-init in your project directory - it detects your solution, scans .csproj SDKs, reads your tech stack, and generates a customized CLAUDE.md. Alternatively, copy a template CLAUDE.md manually. 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 - run 'dotnet tool install -g CWM.RoslynNavigator' for the MCP server, then inside Claude Code run '/plugin marketplace add codewithmukesh/dotnet-claude-kit' and '/plugin install dotnet-claude-kit'. (2) Manual - clone the repo and load with 'claude --plugin-dir ./dotnet-claude-kit'. Full instructions are in the GitHub README.

Does it work with other AI coding tools?

Yes. While built for Claude Code, the kit also supports Cursor (via .cursor/rules/) and Codex CLI (via .codex/AGENTS.md). The core skills, knowledge base, and MCP tools work across platforms.

Is the .NET Claude Kit free and open source?

Yes, 100% free and MIT licensed. The entire kit - skills, agents, commands, rules, templates, hooks, MCP server, 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.7.0 with 7 major component categories: skills, agents, commands, rules, MCP tools, hooks, and templates.

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

47 skills. 10 agents. 16 commands. 15 MCP tools. 5 templates. Free, open source, MIT licensed.

Get the Kit on GitHub Subscribe for Updates

Join 6,500+ 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

Minimal API

API Versioning

Authentication

Error Handling

Resilience

EF Core

Caching

Messaging

Configuration

DI

Modern C#

Docker

CI/CD

Aspire

Logging

Testing

Code Review

Verification Loop

Health Check

Security Scan

De-sloppify

Scaffolding

Project Setup

Convention Learner

Migration Workflow

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

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