ddd-aggregates

Enforce DDD aggregate invariants and boundaries in plain POJOs.

Updated May 8, 2026
One-click install
npx skills add https://github.com/jeremyrdavis/ddd-aggregates --skill ddd-aggregates
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ddd-aggregates
Source: https://github.com/jeremyrdavis/ddd-aggregates/tree/main
Command: npx skills add https://github.com/jeremyrdavis/ddd-aggregates --skill ddd-aggregates

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It streamlines the process of designing and modifying aggregate roots within a Domain-Driven Design context, ensuring adherence to best practices and core principles.

Core Features & Use Cases

  • Design and enforce aggregate invariants in plain POJOs without ORM constraints.
  • Provide validation and consistency when creating or rehydrating aggregates.
  • Use Case: When developing a new domain model, specify invariants, references, and events to maintain a clean bounded context.

Quick Start

Use the ddd-aggregates skill to verify that your aggregate class follows all core DDD rules for design and isolation.

Frequently Asked Questions about ddd-aggregates

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

FAQPage Schema
How do I enforce domain invariants in a Quarkus aggregate root without ORM dependencies?

You enforce domain invariants in a Quarkus aggregate root by designing plain POJOs that validate business rules and maintain consistency without ORM constraints. This approach ensures strict aggregate boundaries and robust domain modeling.

What is an aggregate root in domain-driven design and when do I need it?

An aggregate root in domain-driven design is a primary domain entity that enforces business rules and maintains transactional consistency within a bounded context. You need it when modeling complex business logic that requires strict invariant validation.

How do I validate invariants when rehydrating aggregates in a bounded context?

Validating invariants when rehydrating aggregates in a bounded context requires applying design principles that check business rules during object creation and modification. This ensures your domain classes maintain consistency across transactions.

Can I use plain POJOs for domain modeling instead of ORM-managed entities in Quarkus?

Yes, you can use plain POJOs for domain modeling in Quarkus instead of ORM-managed entities. This allows you to specify invariants, references, and events while maintaining a clean bounded context free from persistence framework constraints.

What is the best way to review domain classes for proper aggregate isolation in DDD?

The best way to review domain classes for proper aggregate isolation in DDD is to verify they follow core design rules for boundary enforcement and invariant validation. This ensures clear separation without ORM dependencies affecting your model.