ddd-architect

Define domain language boundaries and context maps across bounded contexts.

3|Updated Feb 26, 2026
One-click install
npx skills add https://github.com/ralvarezdev/ralvaskills --skill ddd-architect-ralvarezdev
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ddd-architect
Source: https://github.com/ralvarezdev/ralvaskills/tree/main/skills/design/ddd-architect
Command: npx skills add https://github.com/ralvarezdev/ralvaskills --skill ddd-architect-ralvarezdev

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Domain ambiguity across bounded contexts leads to misinterpretations and brittle integrations. DDD-architect provides a structured approach to define and enforce bounded contexts, ubiquitous language, and context-mapping patterns.

Core Features & Use Cases

  • Establish clear language boundaries (ubiquitous language) across domains
  • Guide context mapping, aggregates, and ACL patterns for maintainable architectures
  • Use when designing domain models or restructuring large systems to reduce ambiguity

Quick Start

Identify core domains, define bounded contexts, and draft an initial CONTEXT-MAP to start aligning terminology.

Frequently Asked Questions about ddd-architect

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

FAQPage Schema
How do I resolve semantic ambiguity across bounded contexts in a microservices architecture?

Resolve semantic ambiguity across bounded contexts by defining domain language boundaries and enforcing ubiquitous language. This structured approach prevents misinterpretations and ensures maintainable integrations between complex domain models.

What is the best way to map context boundaries and design aggregates for complex domains?

Map context boundaries and design aggregates by drafting an initial context map to align terminology. This guides strategic decisions regarding domain events, repositories, and integration patterns across multi-context architectures.

When do I need an anti-corruption layer in domain-driven design?

You need an anti-corruption layer in domain-driven design when integrating across bounded contexts with differing ubiquitous languages. It enforces language boundaries and prevents external domain semantics from corrupting your core model.

Can I use strategic DDD to restructure large systems with brittle integrations?

Yes, you can use strategic DDD to restructure large systems with brittle integrations. Defining bounded contexts, context-mapping patterns, and domain events reduces domain ambiguity and aligns terminology for maintainable architectures.

How do I start defining ubiquitous language boundaries for multi-context domains?

Start defining ubiquitous language boundaries by identifying core domains and their bounded contexts. Drafting an initial context map then aligns terminology and establishes clear integration patterns for the architecture.

Does this approach support designing domain events and repositories alongside context mapping?

Yes, this approach supports designing domain events and repositories alongside context mapping. It provides strategic guidance on these concepts within bounded contexts to establish clear implementation boundaries for architecture teams.