dotnet-claude-kit

<p align="center"> <h1 align="center">dotnet-claude-kit</h1> <p align="center"> <strong>Make Claude Code an expert .NET developer.</strong> <br /> 45 skills &bull; 10 specialist agents &bull; 14 slash commands &bull; 10 rules &bull; 5 project templates &bull; 15 MCP tools &bull; automation hooks <br /> Built for .NET 10 / C# 14. Architecture-aware. Token-efficient. </p> </p>

<p align="center"> <a href="#installation">Installation</a> &bull; <a href="#quick-start">Quick Start</a> &bull; <a href="#what-makes-this-10x">10x Features</a> &bull; <a href="#slash-commands-14">Commands</a> &bull; <a href="#knowledge-skills-31">Skills</a> &bull; <a href="#agents-10">Agents</a> &bull; <a href="#rules-10">Rules</a> &bull; <a href="#templates-5">Templates</a> &bull; <a href="#roslyn-mcp-server">MCP Server</a> &bull; <a href="#contributing">Contributing</a> </p>

The Problem

Claude Code is powerful, but out of the box it doesn't know your .NET conventions. It generates DateTime.Now instead of TimeProvider. It wraps EF Core in repository abstractions. It picks an architecture without asking about your domain. It reads entire source files when a Roslyn query would cost 10x fewer tokens.

dotnet-claude-kit fixes all of that.

What This Is

A curated knowledge and action layer that sits between Claude Code and your .NET project. Drop a single CLAUDE.md into your repo and Claude instantly knows:

• •Which architecture fits your project (VSA, Clean Architecture, DDD, Modular Monolith)
• •How to write modern C# 14 with primary constructors, collection expressions, and records
• •How to build minimal APIs with IEndpointGroup auto-discovery, TypedResults, and proper OpenAPI metadata
• •How to use EF Core without repository wrappers, with compiled queries and interceptors
• •How to test with WebApplicationFactory + Testcontainers instead of in-memory fakes
• •How to navigate your codebase via Roslyn semantic analysis instead of expensive file reads
• •How to scaffold complete features, run health checks, review PRs, and enforce conventions

No configuration. No setup wizards. Just copy one file and go.

What Makes This 10x

v0.4.0 adds an action layer on top of the knowledge layer — Claude doesn't just know the right patterns, it actively applies them:

Why dotnet-claude-kit?

The result: Less time reviewing and correcting Claude's output. More time shipping features.

Installation

Plugin Install (Recommended)

Install as a Claude Code plugin — all 45 skills (including 14 slash-command workflows), 10 agents, 10 rules, hooks, and MCP config activate globally:

# In your terminal — install the Roslyn MCP server
dotnet tool install -g CWM.RoslynNavigator

macOS/Linux: If the server fails with "No .NET SDKs were found", set DOTNET_ROOT to your .NET installation root (e.g. /usr/local/share/dotnet). See the MCP server troubleshooting guide.

Then inside a Claude Code session:

# Add the marketplace and install the plugin
/plugin marketplace add codewithmukesh/dotnet-claude-kit
/plugin install dotnet-claude-kit

For local development/testing (loads directly from disk, no install needed):

claude --plugin-dir /path/to/dotnet-claude-kit

Per-Project Setup

Navigate to your project directory (existing or empty) and run:

/dotnet-init

Existing project? It detects your solution, scans .csproj SDKs, reads your tech stack from config, asks architecture questions, and generates a customized CLAUDE.md.

Greenfield project? It asks what you're building, scaffolds the full solution structure (dotnet new sln, projects, Directory.Build.props, src/ and tests/ folders), then generates CLAUDE.md. Follow up with /scaffold to add your first feature.

No manual template copying needed.

<details> <summary><strong>Manual Template Copy (Alternative)</strong></summary>

If you prefer manual setup, copy the template matching your project type:

cp templates/web-api/CLAUDE.md ./CLAUDE.md           # REST API
cp templates/modular-monolith/CLAUDE.md ./CLAUDE.md   # Multi-module system
cp templates/blazor-app/CLAUDE.md ./CLAUDE.md          # Blazor app
cp templates/worker-service/CLAUDE.md ./CLAUDE.md      # Background workers
cp templates/class-library/CLAUDE.md ./CLAUDE.md       # NuGet packages

Replace [ProjectName], update tech stack, choose your architecture.

</details>

Start Claude Code — 45 skills, 10 agents, 10 rules, and 15 MCP tools activate automatically.

That's it. Claude now writes .NET code the way a senior .NET engineer would.

<details> <summary><strong>Manual Install (Alternative)</strong></summary>

If you prefer to clone the repo and wire things up manually:

# 1. Install the MCP server globally
dotnet tool install -g CWM.RoslynNavigator

# 2. Register it in Claude Code at user scope (available in ALL projects)
claude mcp add --scope user cwm-roslyn-navigator -- cwm-roslyn-navigator --solution ${workspaceFolder}

# 3. Clone the kit
git clone https://github.com/codewithmukesh/dotnet-claude-kit.git

# 4. Load as a local plugin (or copy a template manually)
claude --plugin-dir ./dotnet-claude-kit

</details>

What You Get

Before dotnet-claude-kit

// Claude generates this
public class OrderService
{
    private readonly IOrderRepository _repo;  // unnecessary abstraction over EF Core

    public async Task<Order> CreateOrder(CreateOrderDto dto)
    {
        var order = new Order();
        order.CreatedAt = DateTime.Now;  // wrong — use TimeProvider
        order.Items = dto.Items.ToList();
        await _repo.AddAsync(order);
        return order;  // leaks domain entity to API
    }
}

After dotnet-claude-kit

// Claude generates this
public static class CreateOrder
{
    public record Command(string CustomerId, List<OrderItemDto> Items) : IRequest<Result<Response>>;
    public record Response(Guid Id, decimal Total, DateTimeOffset CreatedAt);

    internal sealed class Handler(AppDbContext db, TimeProvider clock)
        : IRequestHandler<Command, Result<Response>>
    {
        public async Task<Result<Response>> Handle(Command request, CancellationToken ct)
        {
            var order = Order.Create(request.CustomerId, request.Items, clock.GetUtcNow());
            db.Orders.Add(order);
            await db.SaveChangesAsync(ct);
            return Result.Success(new Response(order.Id, order.Total, order.CreatedAt));
        }
    }
}

// Each endpoint group auto-discovered — Program.cs never changes
public sealed class OrderEndpoints : IEndpointGroup
{
    public void Map(IEndpointRouteBuilder app)
    {
        var group = app.MapGroup("/api/orders").WithTags("Orders");
        group.MapPost("/", CreateOrderHandler)
            .WithName("CreateOrder").Produces<CreateOrder.Response>(201)
            .ProducesValidationProblem()
            .AddEndpointFilter<ValidationFilter<CreateOrder.Command>>();
    }
}

Result pattern. FluentValidation with endpoint filters. IEndpointGroup auto-discovery. TypedResults with OpenAPI metadata. CancellationToken everywhere. Sealed handlers. TimeProvider injection. DbContext directly. Every pattern comes from the skills in this kit.

Slash Commands (14)

Shortcut workflows that orchestrate skills and agents. Type the command and Claude handles the rest. These are workflow skills — each lives at skills/<name>/SKILL.md, registers its /name automatically, and carries its methodology inline (no separate knowledge twin to load).

Instinct operations (status, export, import) are modes of the instinct-system skill — say "show instincts", "export instincts", or "import instincts".

Rules (10)

Always-loaded conventions that apply to every interaction. Zero configuration — they're active as soon as the plugin is installed.

Knowledge Skills (31)

Code-heavy reference files that teach Claude .NET best practices. Each skill is under 400 lines with concrete code examples, anti-patterns (BAD/GOOD comparisons), and decision guides. (The other 14 of the 45 skills are the workflow orchestrators documented under Slash Commands.)

Agents (10)

Specialist agents that Claude routes queries to automatically. Each agent loads the right skills, uses MCP tools for context, and knows its boundaries.

Templates (5)

Drop-in CLAUDE.md files that configure Claude for specific project types. Copy one file, replace the placeholders, done.

Roslyn MCP Server

Token-efficient codebase navigation via Roslyn semantic analysis. Instead of Claude reading entire source files (500-2000+ tokens each), it queries the MCP server for exactly what it needs (30-150 tokens).

The MCP server starts automatically via .mcp.json. No manual setup required.

See mcp/CWM.RoslynNavigator/README.md for details.

Knowledge Base

Living reference documents updated per .NET release:

Hooks & Automation Scripts (7)

Three Claude Code hooks run automatically (declared in hooks/hooks.json); the rest are git pre-commit hooks and workflow utilities — see hooks/README.md for setup:

Defaults & Decisions

Every default is documented with an ADR explaining why:

Repository Structure

dotnet-claude-kit/
├── CLAUDE.md                    # Instructions for developing THIS repo
├── AGENTS.md                    # Agent routing & orchestration
├── agents/                      # 10 specialist agents
├── skills/                      # 45 skills (incl. 14 slash-command workflows)
├── .claude/rules/               # 10 always-loaded rules
├── templates/                   # 5 drop-in CLAUDE.md templates
├── knowledge/                   # Living reference documents + ADRs
├── mcp/CWM.RoslynNavigator/     # Roslyn MCP server (15 tools)
├── mcp-configs/                 # MCP server config templates
├── hooks/                       # Claude Code hooks + git hooks + utilities
├── docs/                        # Shorthand + longform guides
├── .mcp.json                    # MCP server registration
├── .claude-plugin/              # Plugin marketplace manifests
├── .cursor/rules/               # Cursor IDE compatibility
├── .codex/                      # Codex CLI compatibility
└── .github/workflows/           # CI validation

Multi-Platform Support

dotnet-claude-kit works with multiple AI coding tools:

Documentation

Contributing

See CONTRIBUTING.md for how to add skills, agents, commands, rules, knowledge, templates, and MCP tools.

License

MIT

<p align="center"> Built by <a href="https://codewithmukesh.com">Mukesh Murugan</a> &bull; Powered by Claude Code </p>