ddd-tactical

Guide Domain-Driven Design tactical patterns for polyglot event-driven systems.

5|1|Updated Jun 17, 2026
One-click install
npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill ddd-tactical
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ddd-tactical
Source: https://github.com/roanbrasil/engineer-grade-agent-skills/tree/main/skills/ddd-tactical
Command: npx skills add https://github.com/roanbrasil/engineer-grade-agent-skills --skill ddd-tactical

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common problem of software drifting away from actual business requirements, leading to costly rework, miscommunication between domain experts and development teams, and systems that are rigid and hard to evolve as business rules change.

Core Features & Use Cases

  • Full DDD Tactical Pattern Coverage: Provides actionable guidance for implementing all core DDD tactical building blocks including Entities, Value Objects, Aggregates, Domain Services, Repositories, Factories, and Domain Events, with code examples in Kotlin and Java.
  • Ubiquitous Language & Bounded Context Guidance: Helps teams align development vocabulary with domain expert terminology, and define clear bounded context boundaries to avoid model conflicts across different parts of the business.
  • Anti-Pattern Detection & Architecture Guardrails: Includes checklists and examples of common DDD failures like anemic domain models and bloated aggregates, plus clear layer architecture rules to keep business logic isolated from infrastructure concerns.
  • Use Case Example: For an e-commerce platform building an order management system, use this Skill to model Orders as Aggregates with enforced invariants (e.g., cannot confirm empty orders, cannot exceed customer credit limits), use Value Objects for Money and Email to eliminate primitive-related bugs, and define Domain Events for order confirmation to enable downstream shipping and billing workflows.

Quick Start

Use the ddd-tactical skill to model the core domain for your new order management system, including defining bounded contexts, implementing aggregate roots with invariant enforcement, and setting up repository interfaces in the domain layer.

Frequently Asked Questions about ddd-tactical

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

FAQPage Schema
How do I fix an anemic domain model and keep business logic isolated from infrastructure?

To fix an anemic domain model, apply DDD tactical patterns like rich Entities and Domain Services to enforce business logic separation, keeping domain layers strictly isolated from infrastructure concerns.

How do I enforce aggregate invariants when modeling an e-commerce order management system?

Enforce aggregate invariants in your order management system by modeling Orders as aggregate roots, using rules to prevent confirming empty orders or exceeding customer credit limits directly within the aggregate.

When should I use Value Objects instead of primitives for domain modeling in Java or Kotlin?

Use Value Objects instead of primitives in Java or Kotlin to eliminate primitive obsession bugs, ensuring type safety for domain concepts like Money and Email while maintaining strict domain model boundaries.

What is the best way to establish ubiquitous language and bounded context boundaries for enterprise SaaS?

Establish ubiquitous language for enterprise SaaS by aligning development vocabulary with domain expert terminology and defining clear bounded context boundaries to prevent model conflicts across different business areas.

How do I implement domain events for downstream workflows in an event-driven architecture?

Implement domain events in event-driven architectures by defining event payloads for actions like order confirmation, enabling downstream shipping and billing workflows to react seamlessly to domain state changes.

Why does my software implementation drift away from complex business domain requirements?

Software implementation drifts away from complex business domain requirements due to misalignment between developers and domain experts, which DDD tactical patterns solve by enforcing ubiquitous language and clean layer boundaries.