dotnet-ddd

Architect .NET Core apps with DDD, hexagonal architecture, and CQRS.

10|7|Updated Jan 5, 2026
One-click install
npx skills add https://github.com/cuongtl1992/vibe-skills --skill dotnet-ddd-cuongtl1992
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-ddd
Source: https://github.com/cuongtl1992/vibe-skills/tree/main/skills/backend/dotnet-ddd
Command: npx skills add https://github.com/cuongtl1992/vibe-skills --skill dotnet-ddd-cuongtl1992

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Guides architects to structure .NET Core applications using Domain-Driven Design with Hexagonal and Clean Architecture, outlining patterns for aggregates, domain events, repositories, bounded contexts, and modular layouts.

Core Features & Use Cases

  • DDD-guided modular architecture for scalable .NET Core apps.
  • CQRS with UseCase/Query pattern and outbox integration for reliable event publishing.
  • Hexagonal architecture guidance with ports/adapters and clear dependency direction.
  • Bounded contexts and domain modeling patterns, including aggregates, entities, value objects, and domain events.

Quick Start

Describe how to scaffold a new .NET Core module following DDD with hexagonal architecture and CQRS, including aggregate design, domain events, bounded contexts, and an outbox pattern.

Frequently Asked Questions about dotnet-ddd

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

FAQPage Schema
How do I structure a .NET Core application using Domain-Driven Design?

Structure .NET Core applications with Domain-Driven Design by defining bounded contexts, aggregates, entities, value objects, and domain events. This enforces clear modular layouts and dependency rules to separate write and read models.

What is the best way to implement CQRS and domain events in .NET?

Implement CQRS in .NET by separating UseCase and Query handlers for write and read operations. Reliable domain event publishing is achieved by integrating an outbox pattern within your modular solution layout.

How does hexagonal architecture work with .NET Core and DDD?

Hexagonal architecture in .NET Core uses ports and adapters to isolate domain logic from external infrastructure. Combined with DDD, it enforces clear dependency direction so inner layers remain independent of frameworks or databases.

Can I use this DDD architecture for scalable modular .NET applications?

Yes, this DDD-guided modular architecture is designed for scalable .NET Core apps. It specifies required patterns, folder structures, interfaces, and conventions for bounded contexts to manage complexity in growing systems.

How do I scaffold a new .NET Core module following DDD and CQRS patterns?

Scaffold a new .NET Core module by defining aggregate designs, setting up domain events, and configuring bounded contexts. Include CQRS UseCase and Query handlers alongside an outbox pattern for reliable event publishing.