tactical-ddd

Name: tactical-ddd
Availability: InStock
Author: igoyetche

Apply tactical domain-driven design principles to code analysis and review.

Updated Mar 3, 2026

Search Tags:#code review #refactoring #software design #ddd #domain-driven design #value objects #aggregate design

Ready to run

npx skills add https://github.com/igoyetche/send-to-kindle --skill tactical-ddd-igoyetche

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: tactical-ddd
Source: https://github.com/igoyetche/send-to-kindle/tree/main/.claude/skills/tactical-ddd
Command: npx skills add https://github.com/igoyetche/send-to-kindle --skill tactical-ddd-igoyetche

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers design, refactor, analyze, and review code by applying the core principles and patterns of tactical domain-driven design, leading to more robust, maintainable, and understandable software.

Core Features & Use Cases

Code Analysis & Review: Apply DDD principles to existing codebases to identify areas for improvement.
Design Guidance: Assist in designing new features or refactoring existing ones with DDD patterns like aggregates, value objects, and repositories.
Domain Modeling: Help clarify domain concepts and ensure business logic is isolated and expressive.
Use Case: When designing a new feature for an e-commerce platform, use this Skill to ensure the Order aggregate correctly enforces invariants and that Money is modeled as an immutable value object.

Quick Start

Review the provided code snippet for adherence to the 'Isolate domain logic' principle of tactical DDD.

Frequently Asked Questions about tactical-ddd

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

FAQPage Schema

How do I refactor anemic domain models using domain-driven design?▼

Refactor anemic domain models by isolating domain logic and orchestrating use cases explicitly. Domain-driven design principles transform passive data structures into rich domain models that enforce business invariants and improve maintainability.

What is the best way to design aggregates around invariants in DDD?▼

Designing aggregates around invariants ensures transactional consistency in domain-driven design. Group related entities and value objects into an aggregate root that strictly enforces business rules, preventing invalid states across the entire aggregate boundary.

How do I use immutable value objects for domain modeling?▼

Use immutable value objects for domain modeling to represent concepts without identity, like Money or Address. Immutable value objects prevent accidental state mutation, simplify testing, and ensure explicit expression of domain language in software design.

How do I review code for adherence to tactical DDD principles?▼

Review code for tactical DDD by checking a mandatory list: isolate domain logic, avoid anemic models, separate generic concepts, and verify aggregate design. This code review ensures business logic remains robust, maintainable, and understandable.

When do I need to isolate domain logic in software design?▼

You need to isolate domain logic in software design when business rules become scattered across application layers. Isolating this logic prevents anemic models, ensures explicit expression of business concepts, and maintains clear boundaries for domain-driven design.