dotnet-architecture-good-practices

Enforce DDD and SOLID principles in .NET development with validation and test naming conventions.

Updated Jan 23, 2026
One-click install
npx skills add https://github.com/pingqLIN/skill-0 --skill dotnet-architecture-good-practices
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-architecture-good-practices
Source: https://github.com/pingqLIN/skill-0/tree/main/converted-skills/dotnet-architecture-good-practices
Command: npx skills add https://github.com/pingqLIN/skill-0 --skill dotnet-architecture-good-practices

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides comprehensive guidelines and a rigorous process for developing robust, maintainable, and scalable .NET applications using Domain-Driven Design (DDD) and SOLID principles.

Core Features & Use Cases

  • Architectural Guidance: Enforces DDD patterns (Ubiquitous Language, Bounded Contexts, Aggregates) and SOLID principles.
  • Development Process: Mandates a structured thinking and validation process before and after implementation.
  • Testing Standards: Defines clear testing strategies and naming conventions (MethodName_Condition_ExpectedResult()).
  • Use Case: A senior developer needs to design a new microservice. They consult this Skill to ensure the design adheres to best practices for domain modeling, layer separation, and testability, preventing common architectural pitfalls.

Quick Start

Follow the mandatory thinking process outlined in this skill before implementing any new .NET feature.

Frequently Asked Questions about dotnet-architecture-good-practices

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

FAQPage Schema
How do I implement Domain-Driven Design in .NET architecture?

Implementing Domain-Driven Design in .NET requires enforcing patterns like Ubiquitous Language, Bounded Contexts, and Aggregates. This framework mandates a multi-step validation process before and after implementation to ensure robust domain modeling and strict layer separation.

What is the best way to structure a .NET microservice using SOLID principles?

The best way to structure a .NET microservice using SOLID principles is to follow a rigorous development process that validates architecture, implementation, and testing. This approach prevents common architectural pitfalls by ensuring clear domain modeling and testability.

How do I name unit tests for .NET applications to improve maintainability?

To improve maintainability in .NET applications, name unit tests using the strict MethodName_Condition_ExpectedResult() convention. This testing standard defines clear testing strategies and enforces clarity across the development lifecycle.

Does this .NET architecture framework provide specific guidelines for financial domains?

Yes, this .NET architecture framework provides specific validation guidelines tailored for financial domains. It enforces rigorous security and performance checks alongside standard DDD and SOLID principles to ensure scalable and secure implementations.

When do I need a strict validation process for .NET software design?

You need a strict validation process for .NET software design when developing robust, maintainable, and scalable applications. It mandates structured thinking and architectural validation before and after implementing new features to prevent structural pitfalls.