maister:aggregate-designer

Analyze command conflicts to design correctly scoped DDD aggregates.

Updated May 11, 2026
One-click install
npx skills add https://github.com/rafalwizen/plugin-architecture-test --skill maister-aggregate-designer-rafalwizen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: maister:aggregate-designer
Source: https://github.com/rafalwizen/plugin-architecture-test/tree/main/week7/6-jednostkispojnosci-demo/aggregate-designer
Command: npx skills add https://github.com/rafalwizen/plugin-architecture-test --skill maister-aggregate-designer-rafalwizen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the common problem of incorrectly scoped consistency units (aggregates) in domain-driven design, which lead to either excessive locking contention that hurts system performance or insufficient locking that allows invariant violations in concurrent environments.

Core Features & Use Cases

  • Guided Step-by-Step Workflow: Walks users through 9 structured phases from command extraction to final locking strategy, handling edge cases like time-range conflict traps and transitivity of command conflicts.
  • Conflict Analysis & Boundary Optimization: Generates pairwise conflict matrices to identify which commands must be locked together, and uses business process sequencing and volume probes to avoid over-locking non-conflicting commands.
  • Use Case: A team building a hotel booking system can use this wizard to correctly decide whether to use per-room aggregates (for low traffic) or per-time-slot aggregates (for high traffic) to avoid unnecessary lock contention between non-overlapping reservations.

Quick Start

Invoke the aggregate-designer skill and provide your domain's list of state-changing commands to start the guided aggregate design process.

Frequently Asked Questions about maister:aggregate-designer

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

FAQPage Schema
How do I design DDD aggregates to prevent locking contention and invariant violations?

To design DDD aggregates correctly, you need a guided workflow that performs pairwise conflict analysis on state-changing commands and recommends context-appropriate locking strategies. This prevents excessive locking contention and invariant violations in concurrent systems.

What is the best way to identify aggregate boundaries for concurrent domain models?

The best way to identify aggregate boundaries is generating a pairwise conflict matrix to map which commands must be locked together. This structured conflict analysis uses business process sequencing and volume probes to avoid over-locking non-conflicting commands.

How do I handle time-range conflict traps when scoping aggregate consistency units?

Handling time-range conflict traps requires a structured workflow that accounts for business process sequencing and the transitivity of command conflicts. This ensures your aggregate design applies the correct locking boundaries for time-sensitive state changes.

Can I use a guided wizard for domain-driven design aggregate modeling across different business domains?

Yes, you can use a guided wizard for domain-driven design aggregate modeling across business domains. It walks you through 9 structured phases from command extraction to final locking strategy, handling edge cases like transitive command conflicts.

When should I choose per-room aggregates versus per-time-slot aggregates for high traffic booking systems?

You should choose per-time-slot aggregates for high traffic booking systems to avoid unnecessary lock contention between non-overlapping reservations. A guided aggregate design wizard helps you make this decision by analyzing command conflict volumes.

Why does my domain model suffer from invariant violations in concurrent environments?

Your domain model suffers from invariant violations due to incorrectly scoped consistency units that allow insufficient locking during concurrent state changes. Applying precise locking boundaries through pairwise conflict analysis resolves these invariant violations.