software-engineering-eng-ddd

Name: software-engineering-eng-ddd
Availability: InStock
Author: Rodrigo André Altíssimo

Analyze business domains to produce bounded contexts, aggregates, and ubiquitous language.

Updated May 6, 2025

Search Tags:#ddd #domain-driven design #bounded context #context map #ubiquitous language #domain events #aggregate design

Ready to run

npx skills add https://github.com/rodrigo-altissimo/qiartificial --skill software-engineering-eng-ddd

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: software-engineering-eng-ddd
Source: https://github.com/rodrigo-altissimo/qiartificial/tree/main/.claude/skills/software-engineering/eng-ddd
Command: npx skills add https://github.com/rodrigo-altissimo/qiartificial --skill software-engineering-eng-ddd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you model complex business domains correctly by defining boundaries, language, and consistency rules so your software matches how the business actually works.

Core Features & Use Cases

Strategic DDD modeling: Identify core/supporting/generic subdomains and define bounded contexts so each context uses its own model and language.
Tactical DDD design: Design aggregates, entities vs value objects, repositories, and domain services to enforce invariants and keep transactional consistency clear.
Integration architecture: Build context maps using patterns like ACL, published language, partnership, and event-driven communication.
Workshop facilitation: Guide event storming to discover domain events, aggregates, hotspots, and a first draft of ubiquitous language.
Use case: When refactoring a monolith into bounded contexts, this skill turns ambiguous requirements into a context map, aggregate boundaries, and domain event contracts.

Quick Start

Ask the skill to produce a strategic DDD context map for your domain and then design the key aggregate root for your core subdomain.

Frequently Asked Questions about software-engineering-eng-ddd

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

FAQPage Schema

How do I define bounded contexts when refactoring a monolith?▼

Defining bounded contexts when refactoring a monolith requires strategic Domain-Driven Design to identify subdomains. This process establishes clear consistency boundaries and separate ubiquitous languages so each context operates with its own distinct model.

What is the difference between an aggregate and a value object in tactical DDD?▼

In tactical DDD, an aggregate enforces invariants and transactional consistency around a cluster of entities, while a value object represents a domain concept using attributes without a distinct identity. Proper aggregate design keeps boundaries clear and prevents data inconsistency.

How does event storming work for domain event modeling?▼

Event storming for domain event modeling works by guiding teams through a collaborative workshop to discover domain events, aggregates, and hotspots. This technique produces a first draft of ubiquitous language and identifies integration patterns across contexts.

When do I need an anti-corruption layer for context mapping?▼

You need an anti-corruption layer for context mapping when integrating a core subdomain with external systems or generic subdomains. This integration architecture pattern prevents external models from polluting your ubiquitous language and maintains bounded context integrity.

Can I use this DDD approach for event-driven integration between microservices?▼

Yes, you can use this DDD approach for event-driven integration between microservices. It produces structured domain event contracts and context maps that define communication patterns, ensuring reliable data consistency across distributed bounded contexts.

What is the best way to design aggregate roots for complex business domains?▼

The best way to design aggregate roots for complex business domains is through model-first reasoning and tactical DDD design. This method enforces invariants and establishes transactional consistency rules by carefully separating aggregate roots, entities, and value objects.