Works with the AI Agents you already use
Claude Code
Cursor
Codex CLI
Muse
Dots+22 moreClaude CodeCursorCodex CLIMuseDots
OpenClaw
Manus
Grok
Grok Bot+18 agentsDotnet Pilot - .NET Architecture & Code Review
EF Core migration review, DI verification and clean-architecture checks for .NET 10, with optional Roslyn MCP checks.
Free
Dotnet Pilot - .NET Architecture & Code Review
Example session with this skill installed
Check my solution for layer violations and missing DI registrations. The Roslyn MCP server is connected as roslyn.
- Read your context and instructions
- Compiled the dotnet pilot
Summary
Two defects found in a small synthetic Shop solution (4 projects, .NET SDK 10.0.402), using real dnp-roslyn 0.5.0 output. Both were found without running the app.
| Check | Result |
|---|---|
Architecture (check_architecture_violations, style clean) | 1 violation |
DI completeness (check_di_completeness) | 1 missing registration |
1. Architecture violation
{
"style": "clean",
"violations": [
{
"severity": "error",
"sourceProject": "Shop.Application",
"targetProject": "Shop.Infrastructure",
"rule": "Application must not reference Infrastructure"
}
],
"violationCount": 1
}
2. Missing DI registration
{
"missing": [
{ "interface": "IOrderRepository",
"consumedBy": [ { "type": "OrderService", "file": "Shop.Application/OrderService.cs", "line": 3 } ] }
]
}
GET /orders/{id} would fail at runtime when OrderService is resolved, because nothing registers IOrderRepository.
Next steps (reported, not applied without your approval)
- Remove the
Shop.Application->Shop.Infrastructureproject reference; the interface already lives in Domain. - Add
builder.Services.AddScoped<IOrderRepository, OrderRepository>();inShop.Api/Program.cs.
Sample on a synthetic solution, not a review of real code. Without the Roslyn server the agents fall back to reading .csproj files and Grep; that fallback was not run for this sample.
Connects securely to your tools. The creator never sees your data.
About this skill
Maintaining a clean .NET architecture while shipping features often leads to dependency drift, messy DI wiring and risky EF Core migrations. DotnetPilot gives your coding agent .NET 10 checklists, pattern guides and specialist reviewer playbooks for ASP.NET Core and EF Core solutions.
What it does
- Architecture review checks layer boundaries and project references against clean-architecture rules. With the optional Roslyn MCP server it inspects the compiled solution; without it, the agents read the .csproj files and search the code.
- DI verification finds constructor-injected types that have no registration.
- EF Core migration review covers the right DbContext, CLI-generated migrations, and reading Up() for data loss before anything is applied.
- Pattern guides for Clean Architecture, Vertical Slice, DDD, Polly v8 resilience, OpenTelemetry, Serilog, authentication, caching and error handling. The agent follows them when writing code; they do not configure your project on their own.
- Convention detection: a protocol that reads your existing naming, folder structure and DI style before new code is generated.
How it works
- Initialize by scanning the
*.sln/*.slnxfile to map projects and frameworks. - Learn existing project conventions so new code matches the current style.
- Review architecture or implementation with the specialist agent playbooks for DI, auth, EF Core, performance and security.
- Generate endpoints, migrations or tests using the documented patterns.
Real output
examples/sample-report.md shows output from two Roslyn-backed checks on a small synthetic solution: "Application must not reference Infrastructure", and a missing IOrderRepository registration, both found without running the app.
Frameworks & tools
Written for .NET 10 and C# 14. Covers ASP.NET Core, EF Core, Polly v8, Serilog, OpenTelemetry, xUnit and NSubstitute.
Use cases
- Reviewing a solution for layer violations and missing DI registrations.
- Planning and reviewing EF Core migrations, including column renames, for data loss.
- Wiring JWT bearer or OIDC authentication with the right middleware order.
- Splitting a controller into Vertical Slices, or applying C# 12-14 features (primary constructors, collection expressions) to .NET 10 code.
Known limitations
- .NET only: needs a .sln, .slnx or .csproj. Not for other languages.
- Roslyn-backed checks need the separate
dnp-roslynMCP server (.NET 10 SDK). Agensi does not host it; setup is in docs/MCP-SETUP.md. Everything else works without it. - Tested only in Claude Code, and only partly. Cursor, GitHub Copilot, Codex CLI and Gemini CLI are untested (see docs/COMPATIBILITY.md).
- Not tested on .NET 6 or 8 codebases.
- The review workflow, hooks and statusline are not included; they need the full Claude Code plugin.
What's included (16 skills)
dotnet-pilot
.NET architecture review, DI verification and EF Core migration review for .NET 10 / ASP.NET Core - 15 pattern skills, 9 specialist agents, 12 workflow commands, and optional Roslyn MCP checks. Use when working in a C# solution on layering, DI wiring, migrations, TDD, auth or review. Do not use for non-.NET code or for tasks with no C# solution.
aspnet-api-patterns
ASP.NET Core API patterns — controllers vs minimal API, built-in OpenAPI, middleware order, IExceptionHandler + ProblemDetails, and Asp.Versioning.
authentication
JWT bearer auth, ASP.NET Identity, OIDC, and policy-based authorization patterns for ASP.NET Core APIs.
caching
HybridCache (.NET 9+), output caching, cache-aside pattern, and IMemoryCache — registration, usage, invalidation, and key strategy.
clean-architecture
.NET clean architecture enforcement — layer rules, dependency direction, DI registration patterns, and project reference validation.
convention-learner
Protocol for detecting and replicating existing project conventions before generating new code — naming, folder structure, DI registration, test framework, DTOs, and error handling.
ddd
Domain-Driven Design patterns for .NET — aggregates, value objects, strongly-typed IDs, domain events, repositories, and the DDD variant of the layer rules.
dotnet-project-init
Discovers .NET solution context — projects, frameworks, test runners, EF contexts, architecture style, and package management.
ef-core-patterns
EF Core best practices reference — safe migrations, query optimization, configuration patterns, and common pitfalls.
error-handling
The canonical Result<TValue, TError> type, typed error records, ProblemDetails (RFC 9457), and global exception boundaries for .NET APIs.
logging
Serilog structured logging for ASP.NET Core — setup, message templates, LogContext enrichment, request logging middleware, and log level guidelines.
modern-csharp
C# 12–14 gotchas on .NET 10 — primary constructors, collection expressions, records, pattern matching, nullable reference types, the `field` keyword, extension members, null-conditional assignment, and async/cancellation pitfalls.
opentelemetry
OpenTelemetry SDK for .NET — tracing, custom spans, metrics, .NET Aspire integration, and OTLP exporter configuration.
resilience
Polly v8 resilience patterns for .NET — retry, circuit breaker, timeout, hedging, and IHttpClientFactory integration using Microsoft.Extensions.Resilience.
testing-dotnet
.NET testing patterns — xUnit conventions, integration tests with WebApplicationFactory over Testcontainers, NSubstitute mocking, and test organization.
vertical-slice
Vertical Slice Architecture (VSA) for .NET APIs — feature-first folder structure, IEndpointGroup pattern, cross-cutting concerns, and testing approach.
How to use
Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill passes our trust checks below.
Security scanned
Passed our 8-point scan before listing
Fresh listing
Recently published to Agensi
Free forever
No account required to browse
Trust & safety
Security scanned
Verified clean 2 days ago
- Free to download with an account
Requires
Git