tactical-ddd

Detect anemia signals in TypeScript/JavaScript domain models and propose phase-driven refactor plans.

Updated Jun 18, 2026
One-click install
npx skills add https://github.com/rodrigotoledo/trading-exchange --skill tactical-ddd-rodrigotoledo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tactical-ddd
Source: https://github.com/rodrigotoledo/trading-exchange/tree/main/packages/skills-catalog/skills/%28architecture%29/tactical-ddd
Command: npx skills add https://github.com/rodrigotoledo/trading-exchange --skill tactical-ddd-rodrigotoledo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Detects and remedies anemia in domain models by guiding teams toward rich domain designs and tactical DDD patterns, ensuring invariants are preserved and domain behavior is properly encapsulated.

Core Features & Use Cases

  • Detect anemia signals in codebases and assign a severity score.
  • Classify domain components into Entity, Value Object, Aggregate, or Domain Service and propose targeted refactors.
  • Provide step-by-step refactoring guidance and reference materials to enable safe, incremental improvements.
  • Use case: transform a legacy, getter/setter-heavy domain into expressive, behavior-rich objects with domain events.

Quick Start

Analyze a codebase with Tactical DDD to identify anemia signals and generate a concrete refactor plan.

Frequently Asked Questions about tactical-ddd

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

FAQPage Schema
How do I refactor an anemic domain model into a rich design in TypeScript?

An anemic domain model relies heavily on getters and setters, lacking encapsulated behavior. This Skill detects those anemia signals in your codebase, assigns a severity score, and guides you through a multi-phase refactor to establish rich domain structures using tactical DDD patterns.

What is the best way to identify aggregates and domain events in a legacy codebase?

Classifying aggregates and domain events involves analyzing component responsibilities and invariants. This Skill evaluates your legacy components, classifies them into Entities, Value Objects, Aggregates, or Domain Services, and provides targeted refactor guidance.

How does anemia detection work for domain-driven design refactor plans?

Anemia detection scans for getter-setter-heavy structures and missing domain behavior. The process implements a multi-phase workflow starting with Detect, moving to Assess severity, and concluding with a Refactor phase that introduces domain events and guardrails.

Can I use tactical DDD patterns to safely refactor domain models incrementally?

Yes, you can refactor domain models incrementally by applying step-by-step guardrails. The process provides phase-driven refactoring guidance and reference materials to ensure safe, incremental improvements when transitioning toward rich domain designs.

When do I need a Domain Service instead of an Aggregate in domain-driven design?

A Domain Service is needed when behavior does not naturally belong to a single Aggregate or Entity. The process provides optional Domain Service guidance alongside core classification and refactor rules to correctly encapsulate logic.