domain-driven-design
Plan and route Domain-Driven Design work from strategic modeling to tactical implementation and evented architecture patterns.
Best use case
domain-driven-design is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Plan and route Domain-Driven Design work from strategic modeling to tactical implementation and evented architecture patterns.
Teams using domain-driven-design should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/domain-driven-design/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How domain-driven-design Compares
| Feature / Agent | domain-driven-design | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Plan and route Domain-Driven Design work from strategic modeling to tactical implementation and evented architecture patterns.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
SKILL.md Source
# 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-architect` and `@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 ```text 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.
Related Skills
tailwind-design-system
Build production-ready design systems with Tailwind CSS, including design tokens, component variants, responsive patterns, and accessibility.
api-design-principles
Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers and stand the test of time.
design-mirror
Replicate the visual style of any website and apply it to your existing codebase. Use this skill whenever the user wants to match a site's design, mirror a UI aesthetic, make their app look like another site, or replicate a specific visual style from a URL. Trigger on phrases like 'make it look like', 'match the design of', 'copy the style from', 'I want my app to look like X', 'mirror this design', 'inspired by [url]', or any time the user points at a website and says they want their frontend to match it.
domain-name-brainstormer
Generates creative domain name ideas for your project and checks availability across multiple TLDs (.com, .io, .dev, .ai, etc.). Saves hours of brainstorming and manual checking.
railway-domain
Add, view, or remove domains for Railway services. Use when user wants to add a domain, generate a railway domain, check current domains, get the URL for a service, or remove a domain.
test-driven-development
Use when implementing any feature or bugfix, before writing implementation code
feature-design-assistant
Turn ideas into fully formed designs and specs through natural collaborative dialogue. Use when planning new features, designing architecture, or making significant changes to the codebase.
design-system-starter
Create and evolve design systems with design tokens, component architecture, accessibility guidelines, and documentation templates. Ensures consistent, scalable, and accessible UI across products.
database-schema-designer
Design robust, scalable database schemas for SQL and NoSQL databases. Provides normalization guidelines, indexing strategies, migration patterns, constraint design, and performance optimization. Ensures data integrity, query performance, and maintainable data models.
database-design
Database design principles and decision-making. Schema design, indexing strategy, ORM selection, serverless databases.
design-to-code
Pixel-perfect Figma to React conversion using coderio. Generates production-ready code (TypeScript, Vite, TailwindCSS V4) with high visual fidelity. Features robust error handling, checkpoint recovery, and streamlined execution via helper script.
postgres-schema-design
Comprehensive PostgreSQL-specific table design reference covering data types, indexing, constraints, performance patterns, and advanced features