{
  "markdown": "<p align=\"center\">\n  <h1 align=\"center\">dotnet-claude-kit</h1>\n  <p align=\"center\">\n    <strong>Make Claude Code an expert .NET developer.</strong>\n    <br />\n    47 skills &bull; 10 specialist agents &bull; 16 slash commands &bull; 10 rules &bull; 5 project templates &bull; 22 MCP tools &bull; automation hooks\n    <br />\n    Built for .NET 10 / C# 14. Architecture-aware. Token-efficient.\n  </p>\n</p>\n\n<p align=\"center\">\n  <a href=\"https://codewithmukesh.com/blog/dotnet-claude-kit-guide/\">\n    <img src=\"https://img.shields.io/badge/%F0%9F%93%96%20Read%20the%20Complete%20Guide-codewithmukesh.com-512BD4?style=for-the-badge&logoColor=white\" alt=\"Read the complete dotnet-claude-kit guide\" />\n  </a>\n</p>\n\n<p align=\"center\">\n  <a href=\"https://codewithmukesh.com/blog/dotnet-claude-kit-guide/\"><strong>📖 Full Guide</strong></a> &bull;\n  <a href=\"#installation\">Installation</a> &bull;\n  <a href=\"#quick-start\">Quick Start</a> &bull;\n  <a href=\"#what-makes-this-10x\">10x Features</a> &bull;\n  <a href=\"#slash-commands-14\">Commands</a> &bull;\n  <a href=\"#knowledge-skills-31\">Skills</a> &bull;\n  <a href=\"#agents-10\">Agents</a> &bull;\n  <a href=\"#rules-10\">Rules</a> &bull;\n  <a href=\"#templates-5\">Templates</a> &bull;\n  <a href=\"#roslyn-mcp-server\">MCP Server</a> &bull;\n  <a href=\"#contributing\">Contributing</a>\n</p>\n\n---\n\n> ### 📖 New here? Start with the guide\n>\n> **[How I Use dotnet-claude-kit: Making Claude Code Write Senior-Level .NET →](https://codewithmukesh.com/blog/dotnet-claude-kit-guide/)**\n>\n> The complete walkthrough: install and update the plugin, what happens in your first session, the everyday feature workflow, how the Roslyn MCP server cuts token usage, which commands keep a codebase healthy, plus FAQ and troubleshooting.\n>\n> *This README is the reference. The guide is how to actually use it.*\n\n## The Problem\n\nClaude 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.\n\n**dotnet-claude-kit fixes all of that.**\n\n## What This Is\n\nA 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:\n\n- Which architecture fits your project (VSA, Clean Architecture, DDD, Modular Monolith)\n- How to write modern C# 14 with primary constructors, collection expressions, and records\n- How to build minimal APIs with `IEndpointGroup` auto-discovery, `TypedResults`, and proper OpenAPI metadata\n- How to use EF Core without repository wrappers, with compiled queries and interceptors\n- How to test with `WebApplicationFactory` + `Testcontainers` instead of in-memory fakes\n- How to navigate your codebase via Roslyn semantic analysis instead of expensive file reads\n- **How to scaffold complete features, run health checks, review PRs, and enforce conventions**\n\n**No configuration. No setup wizards. Just copy one file and go.**\n\n## What Makes This 10x\n\nAn **action layer** on top of the knowledge layer — Claude doesn't just know the right patterns, it actively applies and enforces them:\n\n| Capability | What It Does |\n|-----------|-------------|\n| **Surgical Code Analysis** | 22 Roslyn-powered MCP tools with guaranteed bounded responses. `get_symbol_source` reads ONE method body instead of the whole file. `get_file_outline` shows what's in a file before reading it. `resolve_stack_trace` turns an exception into file:line in your own code. `analyze_change_impact` answers \"what breaks if I change this?\" in one call. Every list-returning tool reports `Truncated` — no tool can blow your context window. |\n| **Architecture Enforcement** | `/arch-check` verifies the code still matches its declared architecture (VSA, Clean, DDD, Modular Monolith): dependency direction, layer violations, module leaks, cycles — with file:line evidence and fixes. |\n| **Dependency Health** | `/outdated` reports stale packages, CVEs, and commercial-license traps (MediatR 13+, MassTransit 9+, FluentAssertions 8+, AutoMapper 15+) before an innocent update-all changes your legal position. |\n| **Security Mapping** | `get_endpoint_map` inventories every route with its auth posture (`authorized`/`anonymous`/`unmarked`) in one token-cheap call — `/security-scan` starts every auth audit there. |\n| **DI X-Ray** | `get_di_registrations` maps every service registration with lifetimes, duplicate detection, and captive-dependency risks (singleton holding scoped). |\n| **Agents That Learn** | Specialist agents carry `memory: project` — the code reviewer, architect, and security auditor learn your conventions across sessions instead of rediscovering them. The reviewer is tool-enforced read-only; the cleanup agent works in an isolated worktree. |\n| **Scaffolding** | One command → complete feature with Result pattern, validation, OpenAPI metadata, pagination, CancellationToken, and tests. 9-point checklist enforced. All 4 architectures. |\n| **Health Check** | Automated codebase analysis using MCP tools: anti-pattern scan, diagnostics, dead code detection, test coverage → graded report card. |\n| **PR Review** | Multi-dimensional code review: anti-patterns, diagnostics, API surface changes, blast radius, architecture compliance, test coverage. |\n| **Convention Learning** | Detects project-specific patterns (naming, structure, modifiers) and enforces them in new code. Adapts to your codebase. |\n| **Active Hooks** | Automated quality scripts — format on edit, destructive-command guard, restore on .csproj change — tested on Windows and Linux in CI. |\n| **Always Current** | Every package recommendation verified against NuGet with licensing-trap warnings, and a .NET 11 preview watch so guidance never rots. |\n\n## Why dotnet-claude-kit?\n\n| Metric | Without Kit | With Kit | Impact |\n|--------|-------------|----------|--------|\n| **Architecture decisions** | Claude picks randomly | Asks questions, recommends with rationale | Correct architecture from day one |\n| **Code quality** | Generic C#, legacy patterns | Modern C# 14 with idiomatic .NET 10 | Zero \"fix this pattern\" revision cycles |\n| **Codebase navigation** | Reads entire files (500-2000+ tokens each) | Roslyn MCP queries (30-150 tokens each) | **~10x token savings** on exploration |\n| **Anti-patterns generated** | `DateTime.Now`, repository-over-EF, `new HttpClient()` | `TimeProvider`, direct DbContext, `IHttpClientFactory` | Production-ready on first generation |\n| **Testing approach** | In-memory fakes, mocked everything | `WebApplicationFactory` + `Testcontainers` | Tests that catch real bugs |\n| **Production resilience** | No retry, no circuit breakers | Polly v8 pipelines with telemetry | Handles transient failures automatically |\n\n**The result**: Less time reviewing and correcting Claude's output. More time shipping features.\n\n## Installation\n\n> Prefer a narrated walkthrough with screenshots and troubleshooting? Read **[the complete installation and usage guide](https://codewithmukesh.com/blog/dotnet-claude-kit-guide/)**.\n\n### Plugin Install (Recommended)\n\nInstall as a Claude Code plugin — all 47 skills (including 16 slash-command workflows), 10 agents, hooks, and MCP config activate globally. The 10 rules ship in this repo for you to copy into your project's `.claude/rules/`:\n\n```bash\n# In your terminal — install the Roslyn MCP server\ndotnet tool install -g CWM.RoslynNavigator\n```\n\n> **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](mcp/CWM.RoslynNavigator/README.md#troubleshooting).\n\nThen inside a Claude Code session:\n\n```\n# Add the marketplace and install the plugin\n/plugin marketplace add codewithmukesh/dotnet-claude-kit\n/plugin install dotnet-claude-kit\n```\n\n**For local development/testing** (loads directly from disk, no install needed):\n\n```bash\nclaude --plugin-dir /path/to/dotnet-claude-kit\n```\n\n### Per-Project Setup\n\nNavigate to your project directory (existing or empty) and run:\n\n```bash\n/dotnet-init\n```\n\n**Existing project?** It detects your solution, scans .csproj SDKs, reads your tech stack from config, asks architecture questions, and generates a customized `CLAUDE.md`.\n\n**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.\n\nNo manual template copying needed.\n\n<details>\n<summary><strong>Manual Template Copy (Alternative)</strong></summary>\n\nIf you prefer manual setup, copy the template matching your project type:\n\n```bash\ncp templates/web-api/CLAUDE.md ./CLAUDE.md           # REST API\ncp templates/modular-monolith/CLAUDE.md ./CLAUDE.md   # Multi-module system\ncp templates/blazor-app/CLAUDE.md ./CLAUDE.md          # Blazor app\ncp templates/worker-service/CLAUDE.md ./CLAUDE.md      # Background workers\ncp templates/class-library/CLAUDE.md ./CLAUDE.md       # NuGet packages\n```\n\nReplace `[ProjectName]`, update tech stack, choose your architecture.\n\n</details>\n\nStart Claude Code — 47 skills, 10 agents, and 22 MCP tools activate automatically. Copy the 10 rules into your project's `.claude/rules/` to make them always-loaded.\n\nThat's it. Claude now writes .NET code the way a senior .NET engineer would.\n\n<details>\n<summary><strong>Manual Install (Alternative)</strong></summary>\n\nIf you prefer to clone the repo and wire things up manually:\n\n```bash\n# 1. Install the MCP server globally\ndotnet tool install -g CWM.RoslynNavigator\n\n# 2. Register it in Claude Code at user scope (available in ALL projects)\nclaude mcp add --scope user cwm-roslyn-navigator -- cwm-roslyn-navigator --solution ${workspaceFolder}\n\n# 3. Clone the kit\ngit clone https://github.com/codewithmukesh/dotnet-claude-kit.git\n\n# 4. Load as a local plugin (or copy a template manually)\nclaude --plugin-dir ./dotnet-claude-kit\n```\n\n</details>\n\n## What You Get\n\n### Before dotnet-claude-kit\n\n```csharp\n// Claude generates this\npublic class OrderService\n{\n    private readonly IOrderRepository _repo;  // unnecessary abstraction over EF Core\n\n    public async Task<Order> CreateOrder(CreateOrderDto dto)\n    {\n        var order = new Order();\n        order.CreatedAt = DateTime.Now;  // wrong — use TimeProvider\n        order.Items = dto.Items.ToList();\n        await _repo.AddAsync(order);\n        return order;  // leaks domain entity to API\n    }\n}\n```\n\n### After dotnet-claude-kit\n\n```csharp\n// Claude generates this\npublic static class CreateOrder\n{\n    public record Command(string CustomerId, List<OrderItemDto> Items) : IRequest<Result<Response>>;\n    public record Response(Guid Id, decimal Total, DateTimeOffset CreatedAt);\n\n    internal sealed class Handler(AppDbContext db, TimeProvider clock)\n        : IRequestHandler<Command, Result<Response>>\n    {\n        public async Task<Result<Response>> Handle(Command request, CancellationToken ct)\n        {\n            var order = Order.Create(request.CustomerId, request.Items, clock.GetUtcNow());\n            db.Orders.Add(order);\n            await db.SaveChangesAsync(ct);\n            return Result.Success(new Response(order.Id, order.Total, order.CreatedAt));\n        }\n    }\n}\n```\n\n```csharp\n// Each endpoint group auto-discovered — Program.cs never changes\npublic sealed class OrderEndpoints : IEndpointGroup\n{\n    public void Map(IEndpointRouteBuilder app)\n    {\n        var group = app.MapGroup(\"/api/orders\").WithTags(\"Orders\");\n        group.MapPost(\"/\", CreateOrderHandler)\n            .WithName(\"CreateOrder\").Produces<CreateOrder.Response>(201)\n            .ProducesValidationProblem()\n            .AddEndpointFilter<ValidationFilter<CreateOrder.Command>>();\n    }\n}\n```\n\n**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.\n\n---\n\n## Slash Commands (16)\n\nShortcut 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).\n\n| Command | Purpose | Works With |\n|---------|---------|------------|\n| `/dotnet-init` | Project setup (existing or greenfield) — detects or scaffolds, then generates CLAUDE.md | project-setup skill, dotnet-architect agent |\n| `/spec` | Relentless questioning until human + AI agree on a persisted spec (`docs/specs/`) | feeds /plan and /tdd |\n| `/plan` | Architecture-aware planning — consumes approved specs | architecture-advisor skill, dotnet-architect agent |\n| `/verify` | 7-phase verification: build → analyzers → antipatterns → tests → security → format → diff | — |\n| `/tdd` | Red-green-refactor with xUnit + Testcontainers | testing skill, test-engineer agent |\n| `/scaffold` | Architecture-aware feature scaffolding (all 4 architectures, per-architecture templates included) | dotnet-architect agent |\n| `/code-review` | MCP-powered, blast-radius-prioritized code review | code-reviewer agent |\n| `/build-fix` | Bounded build-fix and test-fix loops with progress detection | build-error-resolver agent |\n| `/checkpoint` | Mid-session save: commit + brief handoff note | — |\n| `/security-scan` | OWASP + secrets + vulnerable dependency audit | security-auditor agent |\n| `/migrate` | EF Core schema, .NET version, and NuGet migrations with rollback | ef-core-specialist agent |\n| `/health-check` | Project health assessment with letter grades (A-F) | code-reviewer agent |\n| `/de-sloppify` | Systematic cleanup: format → dead code → analyzers → sealed | refactor-cleaner agent |\n| `/wrap-up` | Session handoff lifecycle: end-of-session ritual + session-start loading | instinct-system skill |\n| `/outdated` | Dependency health: outdated packages, CVEs, and commercial-license traps | get_nuget_packages MCP tool |\n| `/arch-check` | Architecture conformance: dependency direction, layer violations, module leaks | get_project_graph MCP tool |\n\nInstinct operations (status, export, import) are modes of the [instinct-system](skills/instinct-system/SKILL.md) skill — say \"show instincts\", \"export instincts\", or \"import instincts\".\n\n## Rules (10)\n\nProject-level conventions that apply to every interaction once loaded. Rules ship in this repo (and via the templates) — copy them into your project's `.claude/rules/` to make them always-loaded.\n\n| Rule | Enforces |\n|------|----------|\n| [coding-style](.claude/rules/coding-style.md) | C# 14 conventions, file-scoped namespaces, primary constructors, sealed, records |\n| [architecture](.claude/rules/architecture.md) | Ask before recommending, no repo over EF, feature folders, dependency direction |\n| [security](.claude/rules/security.md) | No hardcoded secrets, parameterized queries, explicit auth, HTTPS |\n| [testing](.claude/rules/testing.md) | Integration-first, WebApplicationFactory + Testcontainers, AAA pattern |\n| [performance](.claude/rules/performance.md) | CancellationToken propagation, TimeProvider, IHttpClientFactory, HybridCache |\n| [error-handling](.claude/rules/error-handling.md) | Result pattern, ProblemDetails, no broad catch, boundary validation |\n| [git-workflow](.claude/rules/git-workflow.md) | Conventional commits, atomic commits, never force-push main |\n| [agents](.claude/rules/agents.md) | MCP-first, subagent routing, skill loading order |\n| [hooks](.claude/rules/hooks.md) | Auto-accept formatting, never skip pre-commit hooks |\n| [packages](.claude/rules/packages.md) | Always use latest stable NuGet versions, never rely on training data versions |\n\n## Knowledge Skills (31)\n\nCode-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 16 of the 47 skills are the workflow orchestrators documented under [Slash Commands](#slash-commands-16).)\n\n| Category | Skills | What Claude Learns |\n|----------|--------|--------------------|\n| **Architecture** | [architecture-advisor](skills/architecture-advisor/SKILL.md), [vertical-slice](skills/vertical-slice/SKILL.md), [clean-architecture](skills/clean-architecture/SKILL.md), [ddd](skills/ddd/SKILL.md), [project-structure](skills/project-structure/SKILL.md) | Ask before recommending. VSA for CRUD, CA for medium complexity, DDD for rich domains, Modular Monolith for bounded contexts. |\n| **Core Language** | [modern-csharp](skills/modern-csharp/SKILL.md) | Primary constructors, collection expressions, `field` keyword, records, pattern matching, spans |\n| **Web / API** | [minimal-api](skills/minimal-api/SKILL.md), [api-versioning](skills/api-versioning/SKILL.md), [authentication](skills/authentication/SKILL.md), [openapi](skills/openapi/SKILL.md), [scalar](skills/scalar/SKILL.md), [httpclient-factory](skills/httpclient-factory/SKILL.md) | `MapGroup`, `TypedResults`, endpoint filters, JWT/OIDC, Asp.Versioning, built-in OpenAPI, typed HTTP clients |\n| **Data** | [ef-core](skills/ef-core/SKILL.md) | No repository wrappers. Compiled queries, interceptors, `ExecuteUpdateAsync`, value converters |\n| **Resilience** | [error-handling](skills/error-handling/SKILL.md), [resilience](skills/resilience/SKILL.md), [caching](skills/caching/SKILL.md), [messaging](skills/messaging/SKILL.md) | Result pattern, Polly v8 pipelines, `HybridCache`, Wolverine/MassTransit, outbox, sagas |\n| **Observability** | [logging](skills/logging/SKILL.md), [serilog](skills/serilog/SKILL.md), [opentelemetry](skills/opentelemetry/SKILL.md) | Health checks and correlation IDs, Serilog structured logging, OpenTelemetry traces and metrics |\n| **Testing** | [testing](skills/testing/SKILL.md) | xUnit v3, `WebApplicationFactory`, `Testcontainers`, Verify snapshots |\n| **DevOps** | [docker](skills/docker/SKILL.md), [container-publish](skills/container-publish/SKILL.md), [ci-cd](skills/ci-cd/SKILL.md), [aspire](skills/aspire/SKILL.md) | Multi-stage builds, Dockerfile-less SDK publishing, GitHub Actions, .NET Aspire orchestration |\n| **Cross-cutting** | [dependency-injection](skills/dependency-injection/SKILL.md), [configuration](skills/configuration/SKILL.md) | Keyed services, Options pattern, secrets management |\n| **Project Setup** | [project-setup](skills/project-setup/SKILL.md), [convention-learner](skills/convention-learner/SKILL.md) | Solution scaffolding, convention detection and enforcement |\n| **Workflow & Learning** | [workflow-mastery](skills/workflow-mastery/SKILL.md), [instinct-system](skills/instinct-system/SKILL.md) | Parallel worktrees, plan mode strategy, subagent patterns, context discipline; confidence-scored instincts, correction capture, discovery logging |\n\n## Agents (10)\n\nSpecialist agents that Claude routes queries to automatically. Each agent loads the right skills, uses MCP tools for context, and knows its boundaries.\n\n| Agent | When It Activates | What It Does |\n|-------|-------------------|-------------|\n| [dotnet-architect](agents/dotnet-architect.md) | \"set up project\", \"architecture\", \"scaffold feature\", \"init project\" | Runs the architecture questionnaire, scaffolds features, initializes projects |\n| [api-designer](agents/api-designer.md) | \"create endpoint\", \"OpenAPI\", \"versioning\" | Designs minimal API endpoints with proper metadata, versioning, and auth |\n| [ef-core-specialist](agents/ef-core-specialist.md) | \"database\", \"migration\", \"query\", \"DbContext\" | Optimizes queries, configures entities, manages migrations safely |\n| [test-engineer](agents/test-engineer.md) | \"write tests\", \"test strategy\", \"coverage\" | Integration-first testing with real databases via Testcontainers |\n| [security-auditor](agents/security-auditor.md) | \"security\", \"authentication\", \"JWT\" | OWASP top 10, auth configuration, secrets management |\n| [performance-analyst](agents/performance-analyst.md) | \"performance\", \"benchmark\", \"caching\" | Identifies hot paths, configures HybridCache, async optimization |\n| [devops-engineer](agents/devops-engineer.md) | \"Docker\", \"CI/CD\", \"Aspire\", \"deploy\" | Multi-stage Dockerfiles, GitHub Actions pipelines, Aspire orchestration |\n| [code-reviewer](agents/code-reviewer.md) | \"review this code\", \"PR review\", \"health check\", \"conventions\" | MCP-driven multi-dimensional review, convention detection and enforcement |\n| [build-error-resolver](agents/build-error-resolver.md) | \"fix build\", \"build errors\", \"won't compile\" | Autonomous build-fix loop: parse errors → categorize → fix → rebuild |\n| [refactor-cleaner](agents/refactor-cleaner.md) | \"clean up\", \"dead code\", \"de-sloppify\" | Systematic cleanup: dead code removal, formatting, sealing, CancellationToken |\n\n## Templates (5)\n\nDrop-in `CLAUDE.md` files that configure Claude for specific project types. Copy one file, replace the placeholders, done.\n\n| Template | For | Includes |\n|----------|-----|----------|\n| [web-api](templates/web-api/) | REST APIs, microservices | Architecture options (VSA/CA/DDD), minimal APIs, EF Core, testing |\n| [modular-monolith](templates/modular-monolith/) | Multi-module systems | Module boundaries, per-module DbContext, Wolverine/MassTransit integration events |\n| [blazor-app](templates/blazor-app/) | Blazor Server / WASM / Auto | Component organization, render mode strategy, bUnit testing |\n| [worker-service](templates/worker-service/) | Background processing | BackgroundService patterns, Wolverine/MassTransit consumers, proper cancellation |\n| [class-library](templates/class-library/) | NuGet packages, shared libraries | Public API design, XML docs, semantic versioning, SourceLink |\n\n## Roslyn MCP Server\n\nToken-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).\n\n| Tool | What It Does | Replaces |\n|------|-------------|----------|\n| `find_symbol` | Locate type/method definitions | Grep/Glob across all .cs files |\n| `find_references` | Find all usages of a symbol | Grep for the type name |\n| `find_implementations` | Find interface implementors | Searching for `: IInterface` |\n| `find_callers` | Find all methods calling a method | Manual grep for method name |\n| `find_overrides` | Find overrides of virtual/abstract methods | Searching for `override` keyword |\n| `get_type_hierarchy` | Inheritance chain + interfaces | Reading multiple files |\n| `get_project_graph` | Solution dependency tree | Parsing .csproj files manually |\n| `get_public_api` | Public API without full file | Reading entire source files |\n| `get_symbol_detail` | Full signature, params, XML docs | Reading entire source files |\n| `get_diagnostics` | Compiler warnings/errors | Running `dotnet build` and parsing |\n| `detect_antipatterns` | 10 .NET anti-pattern rules | Manual code review |\n| `find_dead_code` | Unused types, methods, properties | Manual inspection of all files |\n| `detect_circular_dependencies` | Project and type-level cycles | Manually tracing references |\n| `get_dependency_graph` | Method call chain visualization | Reading multiple files and tracing |\n| `get_test_coverage_map` | Heuristic test coverage mapping | Searching for test files manually |\n| `get_symbol_source` | Exact source of ONE member (bounded, capped) | Reading the whole file for one method |\n| `get_file_outline` | Type/member skeleton of a file, no bodies | Reading the file to see what's in it |\n| `get_nuget_packages` | PackageReference inventory with CPM awareness | Parsing csproj/props files manually |\n| `get_endpoint_map` | Route inventory with auth posture per endpoint | Grepping Map*/controllers by hand |\n| `get_di_registrations` | DI map: lifetimes, duplicates, captive risks | Reading Program.cs and extensions |\n\nThe MCP server starts automatically via `.mcp.json`. No manual setup required.\n\nSee [mcp/CWM.RoslynNavigator/README.md](mcp/CWM.RoslynNavigator/README.md) for details.\n\n## Knowledge Base\n\nLiving reference documents updated per .NET release:\n\n| Document | Purpose |\n|----------|---------|\n| [dotnet-whats-new](knowledge/dotnet-whats-new.md) | .NET 10 / C# 14 features and how to use them |\n| [common-antipatterns](knowledge/common-antipatterns.md) | Patterns Claude should never generate |\n| [package-recommendations](knowledge/package-recommendations.md) | Vetted NuGet packages with rationale and \"when NOT to use\" |\n| [breaking-changes](knowledge/breaking-changes.md) | .NET migration gotchas |\n| [common-infrastructure](knowledge/common-infrastructure.md) | Copy-paste implementations: Result, ValidationFilter, IExceptionHandler, IEndpointGroup + MapEndpoints, pagination |\n| [mediatr-to-mediator-migration](knowledge/mediatr-to-mediator-migration.md) | Step-by-step MediatR → Mediator (MIT, source-generated) migration guide |\n| [decisions/](knowledge/decisions/) | Architecture Decision Records explaining every default |\n\n## Hooks & Automation Scripts (7)\n\nThree Claude Code hooks run automatically (declared in `hooks/hooks.json`); the rest are git pre-commit hooks and workflow utilities — see [hooks/README.md](hooks/README.md) for setup:\n\n| Script | Kind | What It Does |\n|------|-------|-------------|\n| `pre-bash-guard.sh` | Claude Code hook — PreToolUse (Bash) | Blocks destructive git ops (force push, reset --hard), warns on risky commands |\n| `post-edit-format.sh` | Claude Code hook — PostToolUse (*.cs) | Auto-formats C# files after edits |\n| `post-scaffold-restore.sh` | Claude Code hook — PostToolUse (*.csproj) | `dotnet restore` after project file changes |\n| `pre-commit-format.sh` | Git pre-commit (manual install) | `dotnet format --verify-no-changes` ensures consistent formatting |\n| `pre-commit-antipattern.sh` | Git pre-commit (manual install) | Detects `async void`, sync-over-async, `new HttpClient()`, and `DateTime.Now` in the lines a commit adds ([why text, not an analyzer](knowledge/decisions/006-three-tier-antipattern-detection.md)) |\n| `post-test-analyze.sh` | Utility (pipe test output) | Parses test results and outputs actionable summary |\n| `pre-build-validate.sh` | Utility (run before builds) | Validates project structure (solution file, Directory.Build.props, test projects) |\n\n## Defaults & Decisions\n\nEvery default is documented with an ADR explaining **why**:\n\n| Decision | Default | Why |\n|----------|---------|-----|\n| Architecture | Advisor-driven | Asks questions first, then recommends VSA, CA, DDD, or Modular Monolith ([ADR-005](knowledge/decisions/005-multi-architecture.md)) |\n| Error handling | Result pattern | Exceptions are for exceptional cases ([ADR-002](knowledge/decisions/002-result-over-exceptions.md)) |\n| ORM | EF Core | Best developer experience for most scenarios ([ADR-003](knowledge/decisions/003-ef-core-default-orm.md)) |\n| Caching | HybridCache | Built-in stampede protection, L1+L2 ([ADR-004](knowledge/decisions/004-hybrid-cache-default.md)) |\n| APIs | Minimal APIs | Lighter, composable, architecture-agnostic |\n| Testing | Integration-first | `WebApplicationFactory` + `Testcontainers` over in-memory fakes |\n| Time | `TimeProvider` | Testable, injectable, no more `DateTime.Now` |\n| HTTP clients | `IHttpClientFactory` | No more `new HttpClient()` socket exhaustion |\n\n## Repository Structure\n\n```\ndotnet-claude-kit/\n├── CLAUDE.md                    # Instructions for developing THIS repo\n├── AGENTS.md                    # Agent routing & orchestration\n├── agents/                      # 10 specialist agents\n├── skills/                      # 47 skills (incl. 16 slash-command workflows)\n├── .claude/rules/               # 10 always-loaded rules\n├── templates/                   # 5 drop-in CLAUDE.md templates\n├── knowledge/                   # Living reference documents + ADRs\n├── mcp/CWM.RoslynNavigator/     # Roslyn MCP server (22 tools)\n├── mcp-configs/                 # MCP server config templates\n├── hooks/                       # Claude Code hooks + git hooks + utilities\n├── docs/                        # Shorthand + longform guides\n├── .mcp.json                    # MCP server registration\n├── .claude-plugin/              # Plugin marketplace manifests\n├── .cursor/rules/               # Cursor IDE compatibility\n├── .codex/                      # Codex CLI compatibility\n├── opencode.json                # OpenCode config (MCP + rules)\n├── .opencode/                   # OpenCode compatibility\n└── .github/workflows/           # CI validation\n```\n\n## Multi-Platform Support\n\ndotnet-claude-kit works with multiple AI coding tools:\n\n| Platform | Config File | What It Provides |\n|----------|------------|-----------------|\n| **Claude Code** | `.claude-plugin/plugin.json` | Full integration: skills, agents, commands, rules, hooks, MCP |\n| **Cursor** | `.cursor/rules/dotnet-rules.md` | Consolidated .NET rules for Cursor IDE |\n| **Codex CLI** | `.codex/AGENTS.md` | Agent configuration pointing to skills and agents |\n| **OpenCode** | `opencode.json` + `.opencode/AGENTS.md` | Roslyn MCP server, consolidated rules, and agent/skill catalog |\n\n## Documentation\n\n| Guide | For | Content |\n|-------|-----|---------|\n| **[📖 How I Use dotnet-claude-kit](https://codewithmukesh.com/blog/dotnet-claude-kit-guide/)** | **Start here** | **Install, update, first session, everyday feature workflow, Roslyn MCP token savings, health commands, FAQ, troubleshooting** |\n| [Shorthand Guide](docs/shorthand-guide.md) | Quick reference | All commands, skills, agents, hooks, MCP tools with cross-reference matrix |\n| [Longform Guide](docs/longform-guide.md) | Deep dive | Workflows, token optimization, autonomous patterns, troubleshooting |\n\n## Contributing\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md) for how to add skills, agents, commands, rules, knowledge, templates, and MCP tools.\n\n## License\n\n[MIT](LICENSE)\n\n---\n\n<p align=\"center\">\n  <strong>📖 Read the complete guide: <a href=\"https://codewithmukesh.com/blog/dotnet-claude-kit-guide/\">How I Use dotnet-claude-kit</a></strong>\n</p>\n\n<p align=\"center\">\n  Built by <a href=\"https://codewithmukesh.com\">Mukesh Murugan</a> &bull; Powered by Claude Code\n</p>\n",
  "bytes": 30443,
  "sha": "1ae3e31c8bfd65753bb84d8d387c749d46b29a7487aff7443f497a8739cb128c",
  "repo_slug": "codewithmukesh/dotnet-claude-kit",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/skl_codewithmukesh_dotnet_claude_kit_openapi_6cdafeae/readme"
}