dotnet-architect

Design production-grade .NET API architecture with EF Core, Dapper, and health checks.

54|18|Updated Jan 21, 2026
One-click install
npx skills add https://github.com/hainamchung/agent-assistant --skill dotnet-architect-hainamchung
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-architect
Source: https://github.com/hainamchung/agent-assistant/tree/main/skills/dotnet-architect
Command: npx skills add https://github.com/hainamchung/agent-assistant --skill dotnet-architect-hainamchung

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides a structured approach for designing production-grade .NET backends, ensuring maintainability, performance, and alignment with enterprise architectural patterns.

Core Features & Use Cases

  • C# language mastery and modern patterns for robust APIs
  • ASP.NET Core expertise covering minimal and controller-based APIs, dependency injection, middleware, authentication, health checks, and hosting
  • Data access strategies with EF Core, Dapper, and CQRS patterns
  • Caching, performance tuning, memory management, and profiling
  • Testing, validation, and documentation for maintainable code
  • Architecture patterns such as Clean Architecture, Domain-Driven Design, and microservices readiness
  • DevOps readiness including Docker, Kubernetes, and CI/CD integration

Quick Start

Draft a production-ready .NET API architecture plan for a new microservice, including patterns, tech stack, and validation steps

Frequently Asked Questions about dotnet-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is the best way to structure a production-grade .NET backend service?

Designing a .NET API architecture involves applying Clean Architecture and Domain-Driven Design patterns to separate concerns. This ensures reliability, maintainability, and performance across data access, authentication, and deployment modules.

How do I design a .NET API architecture plan for a new microservice?

Draft your microservice architecture by defining the tech stack including ASP.NET Core, EF Core, and Dapper. Implement Clean Architecture patterns, configure dependency injection, and establish validation steps for a production-ready .NET API.

When should I use EF Core vs Dapper for data access in ASP.NET Core?

Use EF Core for domain modeling and CQRS command operations requiring change tracking, while Dapper optimizes high-performance read queries. A robust .NET backend architecture often combines both to balance maintainability and speed.

Does Clean Architecture work with minimal APIs in ASP.NET Core?

Clean Architecture integrates with both minimal and controller-based APIs in ASP.NET Core. You configure dependency injection and middleware to maintain separation of concerns, ensuring robust error handling, logging, and monitoring across both hosting styles.

What testing and validation strategies are needed for a robust .NET API?

A robust .NET API requires comprehensive testing, validation, and documentation strategies to ensure maintainable code. This includes validating domain logic, testing CQRS patterns, and verifying dependency injection and error handling mechanisms.

How do I prepare a .NET API for Docker and Kubernetes deployment?

Prepare your .NET API for Docker and Kubernetes by implementing health checks and monitoring endpoints. Configure dependency injection for container environments and integrate CI/CD pipelines to ensure reliable deployment of your clean architecture.