tactical-ddd

Detects anemic domain models, validates and refactors them into rich domain models, and enforces tactical DDD patterns (Entities, Value Objects, Aggregates, Domain Services, Domain Events). Use when the user asks to validate, review, or check domain models or DDD code; detect anemia; refactor domain objects; improve encapsulation; or mentions terms like "anemic model", "rich domain", "aggregate", "value object", "domain event", "ubiquitous language", "is this good DDD", "does this follow DDD", or "check my domain". Do NOT use for module or service boundary design, architectural decomposition, strategic DDD context mapping, or code outside the domain layer (DTOs, controllers, infrastructure adapters).

Quality

86%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Quality

Content

72%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A tightly written, well-organized body that assumes Claude's knowledge and routes intent effectively, but it is undermined by two defects: no verification step after the destructive refactor, and three referenced detail files that do not exist in the bundle. Fixing these would lift the workflow and disclosure scores.

Suggestions

Add a post-refactor verification step to Phase 3 (e.g., run the test suite or confirm behavior is preserved) so the destructive workflow has a proper validate-fix-retry loop and is not capped at 3.

Create the missing bundle files detection.md, refactoring.md, and reference.md (or inline their key content and remove the dangling links) so the progressive-disclosure references actually resolve.

Include at least one concrete before/after code diff example in the body or in refactoring.md to make the refactor moves directly executable rather than purely descriptive.

Dimension	Reasoning	Score
Conciseness	The body is lean and assumes Claude's competence — no teaching of what DDD/Entities/PDFs are, terse tables, a 4-line signal code block, and 8 one-line Golden Rules; the brief dash-clauses in the rules are enforcement reminders rather than concept explanations, fitting the score-5 'every token earns its place' anchor over the minor-over-explanation score-4.	5 / 5
Actionability	Provides concrete actionable structure — a building-block decision table, an ordered 5-move refactor procedure, and an output-format template — but lacks executable before/after code examples and defers detailed moves to refactoring.md; as an instruction skill the guidance is mostly actionable with minor gaps, matching score-4 rather than the incomplete score-3.	4 / 5
Workflow Clarity	The intent-routing table and Phase 1/2/3 sequence are clearly structured with a pre-refactor checkpoint ("Ask 'Would you like me to apply these fixes?' before proceeding"), but refactoring is a destructive operation with no post-refactor verification step, so per the destructive-operation cap workflow_clarity is capped at 3.	3 / 5
Progressive Disclosure	The overview is well-structured and references (detection.md, refactoring.md, reference.md) are clearly signaled inline at one level deep, but none of these referenced files actually exist — no references/, scripts/, or assets/ directories are present — so the progressive-disclosure mechanism is broken and Claude cannot navigate to the detail, landing at score-3 despite good signaling.	3 / 5
	Total	15 / 20 Passed

Description

100%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, well-constructed description that clearly states capabilities, provides comprehensive natural trigger terms, answers both what and when explicitly, and includes an excellent exclusion clause that distinguishes tactical from strategic DDD. No meaningful gaps.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions — 'Detects anemic domain models, validates and refactors them into rich domain models, and enforces tactical DDD patterns (Entities, Value Objects, Aggregates, Domain Services, Domain Events)' — with comprehensive coverage of capabilities, matching the score-5 anchor rather than the minor-gaps score-4.	5 / 5
Completeness	Explicitly answers both what (detect/validate/refactor/enforce DDD patterns) and when ("Use when the user asks to validate, review, or check domain models... or mentions terms like...") with concrete trigger phrases, matching the score-5 anchor exactly.	5 / 5
Trigger Term Quality	Comprehensive natural trigger terms including synonyms and phrasings users actually say — "anemic model", "rich domain", "aggregate", "is this good DDD", "does this follow DDD", "check my domain" — matching the comprehensive-coverage score-5 anchor; no file extensions are relevant for this code-concept skill.	5 / 5
Distinctiveness Conflict Risk	Clear niche (tactical DDD / rich domain modeling) with distinct triggers and an explicit exclusion clause — "Do NOT use for module or service boundary design, architectural decomposition, strategic DDD context mapping, or code outside the domain layer" — giving minimal conflict risk per the score-5 anchor.	5 / 5
	Total	20 / 20 Passed

Validation

93%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
relative_links	Relative link issues: 4 missing	Warning

	Total	15 / 16 Passed

Repository: tech-leads-club/agent-skills
Path: packages/skills-catalog/skills/(architecture)/tactical-ddd/SKILL.md
Commit: 120b676

Reviewed: 5 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.