dotnet-ai-kit

Use when designing gRPC services, proto files, or adding gRPC-Web or JSON transcoding.

Use when writing async code, propagating CancellationTokens, or fixing async/await pitfalls.

Use when applying or enforcing C# coding style — namespaces, sealed classes, var usage, XML docs.

Use when applying modern C# idioms — records, pattern matching, primary constructors, collection expressions.

Use when registering services, choosing lifetimes, or implementing DI patterns like decorator or keyed services.

Use when selecting or implementing design patterns in C# — factory, builder, strategy, decorator, or mediator.

Use when implementing error handling with domain exceptions, ProblemDetails, or RpcException mapping.

Use when applying functional patterns in C# — Result types, railway-oriented programming, or immutability.

Use when adopting C# 12/13/14 features — primary constructors, collection expressions, or field keyword.

Use when evaluating code against SOLID principles or deciding when to apply or skip them.

Use when adding gRPC interceptors for exception mapping, culture switching, or claims extraction.

Use when designing proto files or implementing gRPC service classes with MediatR.

Use when adding FluentValidation to gRPC requests with Calzolari integration.

Use when creating implementation plans that need mode-specific templates.

Use when creating RESTful API controllers with MediatR dispatch and ProblemDetails error responses.

Use when building minimal API endpoints with route groups, filters, or TypedResults.

Use when configuring EF Core event store with discriminator mapping for event sourcing.

Use when detecting .NET project type, architecture pattern, or solution structure.

Use when setting up JWT authentication, token generation, or refresh token flows.

Use when following the Specification-Driven Development lifecycle from plan through ship.

Use when adding caching to .NET APIs or optimizing response times with distributed cache, output cache, or ETags.

Use when configuring API response formats, custom formatters, or Accept header handling.

Use when building controller-based REST APIs with action results, model binding, or MediatR integration.

Use when setting up OpenAPI spec generation or Scalar API documentation UI.

Use when adding rate limiting or throttling to .NET API endpoints.

Use when configuring Scalar API documentation UI for a .NET project.

Use when adding real-time communication with SignalR hubs, WebSocket connections, or push notifications.

Use when adding API versioning or managing multiple API versions in a .NET project.

Use when choosing between architecture patterns (VSA, Clean Architecture, DDD, Modular Monolith, Microservices) for a new project.

Use when implementing or enforcing Clean Architecture with 4-layer separation and dependency inversion.

Use when implementing CQRS with separate read/write models and MediatR pipeline behaviors.

Use when modeling domain logic with aggregates, value objects, domain events, or bounded contexts.

Use when structuring a modular monolith with module isolation and inter-module communication.

Use when adding multi-tenant support with tenant isolation, per-tenant databases, or query filters.

Use when implementing Vertical Slice Architecture with feature folders and co-located code.

Use when setting up IConfiguration, Options pattern, appsettings layering, or user secrets.

Use when adding FluentValidation validators, custom rules, or async validation to a .NET project.

Use when mapping between DTOs and domain objects — manual mapping, LINQ projections, or AutoMapper.

Use when creating a new CQRS command with handler and FluentValidation validator.

Use when implementing MediatR request handlers, notification handlers, or command/query dispatch.