skills.rest
luxunxiansheng
luxunxianshengCOMMUNITY
Explore all skills by this author →
GitHub

domain-driven-design

Model domain concepts and bounded contexts to prevent leakage between models.

Updated Aug 23, 2026
Search Tags:#architecture#ddd#domain-driven-design#bounded-context#aggregates#ubiquitous-language#domain-events
One-click install
npx skills add https://github.com/luxunxiansheng/skills2026 --skill domain-driven-design-luxunxiansheng
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: domain-driven-design
Source: https://github.com/luxunxiansheng/skills2026/tree/main/domain-driven-design
Command: npx skills add https://github.com/luxunxiansheng/skills2026 --skill domain-driven-design-luxunxiansheng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Domain-driven design (DDD) helps teams align software models with business concepts by organizing code around bounded contexts, ubiquitous language, and clear aggregates, preventing modeling drift and miscommunication.

Core Features & Use Cases

  • Define bounded contexts and ubiquitous language to keep teams aligned across domains.
  • Establish aggregates, value objects, and domain services to protect invariants and orchestrate complex workflows.
  • Apply Layered Architecture guidance to separate interfaces, application logic, domain rules, and infrastructure.

Quick Start

Define a bounded context for your core domain and model an aggregate with its root entity to begin enforcing invariants.

Frequently Asked Questions about domain-driven-design

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

FAQPage Schema
How do I model aggregates and enforce invariants in domain-driven design?▼

To model aggregates in domain-driven design, you define a root entity to encapsulate internal state and enforce invariants, preventing modeling drift and miscommunication across bounded contexts.

What is the best way to separate infrastructure from domain rules in a layered architecture?▼

Separating infrastructure in a layered architecture requires isolating domain rules from interfaces and application logic, ensuring clear boundaries and preventing model leakage across layers.

When do I need bounded contexts and ubiquitous language for my software architecture?▼

You need bounded contexts and ubiquitous language when aligning software models with business concepts, organizing code around specific domains to keep teams aligned and prevent modeling drift.

Can I use domain events and domain services to orchestrate complex workflows?▼

Yes, you can establish domain services and domain events to orchestrate complex workflows, protecting invariants and coordinating interactions between aggregates across different bounded contexts.

Does domain-driven design work for preventing model leakage between different application layers?▼

Domain-driven design works for preventing model leakage by applying layer isolation rules, ensuring interfaces, application logic, domain rules, and infrastructure maintain clear architectural boundaries.

How to start defining a core domain and bounded context for a new project?▼

To start defining a core domain, model a bounded context and create an aggregate with its root entity to begin enforcing invariants and aligning ubiquitous language with business concepts.

Related Skills

Explore More Software Engineering Skills→
DVNghiemDVNghiem
20

ddd-architecture

Model complex business domains with bounded contexts, aggregates, and domain events.

Community
Advanced
yeeehaoooyeeehaooo

domain-event

Publish immutable domain events from entities with post-commit dispatch.

Community
Advanced
PremModhaOfficialPremModhaOfficial
1

ddd-decomposition

Identify bounded contexts and service boundaries for multi-tenant Go microservices.

Community
Advanced
MovchanetsMovchanets

architecture-patterns

Design maintainable backend architectures with domain boundaries and dependency rules.

Community
Advanced