Domain Driven Design
- 1 installs
- 44k repo stars
- Updated July 27, 2026
- sickn33/antigravity-awesome-skills
This is a copy of domain-driven-design by davila7 - installs and ranking accrue to the original listing.
domain-driven-design is an agent skill that plans DDD from strategic boundaries through tactical and evented architecture routing.
About
domain-driven-design is a planning and routing skill for developers and small teams facing real business complexity—not generic CRUD. It forces a viability check so you do not pay DDD ceremony when rules are stable and integrations are simple. When warranted, it prioritizes strategic artifacts: subdomains, bounded contexts, and a shared language glossary before any tactical coding advice. A routing map sends the agent toward focused companion skills for strategic design, context mapping, and implementation patterns, and it frames when evented architectures like CQRS, event sourcing, sagas, or projections are justified from domain pressure rather than hype. Use it when multiple teams or fast-changing rules threaten model collisions, or when auditability and invariants matter. Skip it for localized bug fixes or when nobody can act as a domain proxy.
- Viability check: commit to full DDD only when at least two complexity signals apply
- Strategic artifacts first—subdomains, bounded contexts, ubiquitous language glossary
- Routing map to specialized skills for strategic design, context mapping, and tactical patterns
- Connects domain needs to CQRS, event sourcing, sagas, and projections planning
- Explicit success criteria and evidence per stage before implementation
Domain Driven Design by the numbers
- 1 all-time installs (skills.sh)
- Security screen: LOW risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill domain-driven-designAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1 |
|---|---|
| repo stars | ★ 44k |
| Security audit | 3 / 3 scanners passed |
| Last updated | July 27, 2026 |
| Repository | sickn33/antigravity-awesome-skills ↗ |
What it does
Decide whether full DDD is worth it, produce strategic boundaries, and route the agent to the right tactical DDD skills before you code the wrong model.
Who is it for?
Best when you're shipping multi-module APIs or agents where business rules, team boundaries, or integration contracts are unstable.
Skip if: Simple CRUD apps, one-off bug fixes, or efforts with zero access to domain knowledge and no stand-in product expert.
When should I use this skill?
You need to model a complex business domain, decide if full DDD is justified, or plan CQRS, event sourcing, sagas, or projections from domain needs.
What you get
You get a viability decision, strategic boundary artifacts, and a routed next focus (strategic, integration, or tactical) with success criteria before implementation starts.
- DDD viability assessment with evidence
- Strategic artifacts outline: subdomains, bounded contexts, glossary
- Routing recommendation to the next specialized DDD skill for the current task
By the numbers
- Full DDD recommended only when at least two of four viability signals are true
- Four-step instruction flow: viability, strategic artifacts, routing, success criteria
Files
Domain-Driven Design
Use this skill when
- You need to model a complex business domain with explicit boundaries.
- You want to decide whether full DDD is worth the added complexity.
- You need to connect strategic design decisions to implementation patterns.
- You are planning CQRS, event sourcing, sagas, or projections from domain needs.
Do not use this skill when
- The problem is simple CRUD with low business complexity.
- You only need localized bug fixes.
- There is no access to domain knowledge and no proxy product expert.
Instructions
1. Run a viability check before committing to full DDD. 2. Produce strategic artifacts first: subdomains, bounded contexts, language glossary. 3. Route to specialized skills based on current task. 4. Define success criteria and evidence for each stage.
Viability check
Use full DDD only when at least two of these are true:
- Business rules are complex or fast-changing.
- Multiple teams are causing model collisions.
- Integration contracts are unstable.
- Auditability and explicit invariants are critical.
Routing map
- Strategic model and boundaries:
@ddd-strategic-design - Cross-context integrations and translation:
@ddd-context-mapping - Tactical code modeling:
@ddd-tactical-patterns - Read/write separation:
@cqrs-implementation - Event history as source of truth:
@event-sourcing-architectand@event-store-design - Long-running workflows:
@saga-orchestration - Read models:
@projection-patterns - Decision log:
@architecture-decision-records
If templates are needed, open references/ddd-deliverables.md.
Output requirements
Always return:
- Scope and assumptions
- Current stage (strategic, tactical, or evented)
- Explicit artifacts produced
- Open risks and next step recommendation
Examples
Use @domain-driven-design to assess if this billing platform should adopt full DDD.
Then route to the right next skill and list artifacts we must produce this week.Limitations
- This skill does not replace direct workshops with domain experts.
- It does not provide framework-specific code generation.
- It should not be used as a justification to over-engineer simple systems.
DDD Deliverables Checklist
Use this checklist to keep DDD adoption practical and measurable.
Strategic deliverables
- Subdomain map (core, supporting, generic)
- Bounded context map and ownership
- Ubiquitous language glossary
- 1-2 ADRs documenting critical boundary decisions
Tactical deliverables
- Aggregate list with invariants
- Value object list
- Domain events list
- Repository contracts and transaction boundaries
Evented deliverables (only when required)
- Command and query separation rationale
- Event schema versioning policy
- Saga compensation matrix
- Projection rebuild strategy
Related skills
Lark Openapi ExplorerInstantly explore, test, and generate calls against the full Lark (Feishu) OpenAPI surface without leaving their agent workflow.471k
Lark EventConsume real-time events from Lark/Feishu as structured NDJSON streams inside AI agent workflows.382k15.8kLark Openapi ExplorerWhen an existing Lark/Feishu skill or CLI command cannot fulfill a specific requirement and they need to discover and invoke the exact native OpenAPI endpoint.381k15.8k
Just ScrapeQuickly search, crawl, extract structured JSON, or monitor web pages without writing custom scraping code.245k37Lark AppsQuery the current visibility and permission scope of a Lark (Feishu) app without writing HTTP client code.230k15.8k
SupabaseGet accurate, up-to-date Supabase implementation guidance across database, auth, realtime, storage, edge functions and vector search without relying on outd182k2.4kHow it compares
Architecture planning router with explicit anti-CRUD gates—not a code generator or a single bounded-context implementation template.
FAQ
Who is domain-driven-design for?
Developers and small teams modeling non-trivial business domains who need strategic boundaries before backend and event-driven implementation choices.
When should I use domain-driven-design?
During Validate scoping when rules are complex; during Build backend/PM when contexts collide; before Ship review when integration contracts need explicit translation layers.
Is domain-driven-design safe to install?
It is documentation and routing only—review the Security Audits panel on this page; risk is low, but follow your repo policies when linked skills touch code.