skills.rest
davidrrowley
davidrrowleyCOMMUNITY
Explore all skills by this author →
Website𝕏@davidrrowleyGitHub

domain-driven-design

Model business domains and define bounded contexts with aggregates and invariants.

Updated Apr 12, 2026
Search Tags:#ddd#domain-driven-design#bounded-context#aggregates#domain-events#context-map#event-storming
One-click install
npx skills add https://github.com/davidrrowley/CortexYouV3 --skill domain-driven-design-davidrrowley
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: domain-driven-design
Source: https://github.com/davidrrowley/CortexYouV3/tree/main/.agents/skills/domain-driven-design
Command: npx skills add https://github.com/davidrrowley/CortexYouV3 --skill domain-driven-design-davidrrowley

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Domain-Driven Design helps teams align software structure with business reality by identifying bounded contexts, aggregates, and the ubiquitous language that prevents model drift and unclear responsibilities. It reduces architecture churn when decomposing monoliths, designing microservices, or collaborating with domain experts.

Core Features & Use Cases

  • Strategic decomposition: Identify subdomains (Core, Supporting, Generic) and map bounded contexts for clear ownership and investment decisions.
  • Tactical modeling: Design entities, value objects, aggregates, repositories, factories, and domain services with rules for invariants and consistency.
  • Event-driven design & integration: Run event storming, name domain events, choose context mapping patterns (ACL, Published Language, Shared Kernel) and justify microservice boundaries.
  • Use Case: During a monolith split, run event storming to name events, derive aggregate boundaries, and produce a context map that guides service decomposition and integration contracts.

Quick Start

Map domain events from a stakeholder workshop, draw tentative bounded contexts, and list aggregates with their key 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 identify bounded contexts when decomposing a monolith?▼

Identify bounded contexts by mapping domain events from stakeholder workshops, drawing tentative context boundaries, and listing aggregates with key invariants to guide decomposition. This aligns software structure with business responsibilities and reduces architecture churn.

What is the best way to run event storming for microservice boundary decisions?▼

Run event storming by mapping domain events from a stakeholder workshop, deriving aggregate boundaries, and producing a context map. This context map justifies microservice boundaries and defines integration contracts like ACLs and published languages.

How do I design aggregates and specify invariants in domain-driven design?▼

Design aggregates in domain-driven design by modeling entities, value objects, and repositories while specifying rules for invariants and consistency boundaries. This tactical modeling ensures clear ownership and prevents model drift within bounded contexts.

When do I need a context map and integration patterns like ACLs in domain-driven design?▼

You need a context map and integration patterns like ACLs when aligning software design with business rules across multiple bounded contexts. Context mapping helps choose patterns like Shared Kernel or Published Language to manage relationships and integration contracts.

Can I use domain-driven design for strategic decomposition of subdomains?▼

Yes, use domain-driven design for strategic decomposition to identify subdomains as Core, Supporting, or Generic. Mapping these bounded contexts enables clear ownership and informs investment decisions during architecture design sessions.

Why does domain-driven design require establishing a ubiquitous language with domain experts?▼

Domain-driven design requires establishing a ubiquitous language with domain experts to prevent model drift and unclear responsibilities. Aligning software structure with business reality ensures that architecture design sessions accurately reflect business rules.

Related Skills

Explore More Software Engineering Skills→
safzanpiranisafzanpirani
1

ubiquitous-language

Extract domain terms and flag ambiguities from conversations into a glossary.

Community
Intermediate
PremModhaOfficialPremModhaOfficial
1

ddd-decomposition

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

Community
Advanced
joaquimscostajoaquimscosta
21

domain-driven-design

Apply Domain-Driven Design patterns to model complex domains with bounded contexts and aggregates.

Community
Advanced
efekrbasefekrbas
41

ddd-strategic-design

Analyze business domains into subdomains, bounded contexts, and ubiquitous language artifacts.

Community
Intermediate