ddd-anti-patterns
Use when identifying DDD anti-patterns and smells in code or design — phrases like "anemic domain model", "primitive obsession", "leaky repository", "smart UI", "transaction script", "god aggregate", "big ball of mud". Catalogs the common DDD anti-patterns with symptoms, why each is wrong, and the pattern skill that explains the fix.
How do I install this agent skill?
npx skills add https://github.com/yonatankarp/software-design-skills --skill ddd-anti-patternsIs this agent skill safe to install?
- Gen Agent Trust Hubpass
This skill is a purely informational reference catalog for Domain-Driven Design (DDD) anti-patterns. It contains no executable code, network operations, or external dependencies.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
One-line summary
A reference catalog of the most common DDD anti-patterns, each with symptoms and a link to the pattern skill that explains the fix.
When to use this skill
- Code review walks (
ddd-reviewcites this for each finding). - Spotting smells during a refactor (
ddd-refactoruses this catalog as the smell-to-target-shape lookup). - Debating "is this really DDD or just CRUD-with-pattern-names".
- Onboarding teammates — a single page that names the things to avoid.
When NOT to use this skill
- You already know which pattern applies — go directly to it.
- The question is about what to build, not what not to build → use
ddd-design.
Core content
The catalog. Each entry: name, symptoms, why it is wrong, fix.
Anemic Domain Model. Entities are data bags — fields with getters and setters, no behavior. All the logic lives in *Service classes. Wrong because the model carries no domain knowledge; services become transaction scripts over DTOs. Fix: push behavior onto entities. See ddd-entity, ddd-domain-service.
Primitive Obsession. Domain concepts encoded as raw String, Long, BigDecimal, etc. — String customerId, Long amount, String currency. Wrong because invariants aren't enforced, two concepts sharing a primitive type become interchangeable, and operations get scattered into static helpers. Fix: extract value objects. See ddd-value-object.
God Aggregate. One aggregate that owns half the model. Symptoms: loading it pulls in hundreds of rows; lock contention spikes; transactions become unwieldy. Wrong because aggregate boundaries should be transactional boundaries. Fix: split by what must change together. See ddd-aggregate.
Leaky Repository. The repository exposes persistence types (Query, Predicate, EntityManager, framework JpaRepository). Wrong because the domain layer now depends on persistence concerns and can't be tested in isolation. Fix: domain-language methods on a domain-layer interface, with infrastructure-layer implementations. See ddd-repository.
Transaction Script masquerading as DDD. Services full of procedural logic over data DTOs, with classes named *Manager, *Helper, *Processor. Wrong because there is no actual domain layer — the names create the illusion of DDD. Fix: behavior on entities; *Service only when truly stateless and cross-aggregate. See ddd-domain-service.
Smart UI. Business rules embedded in controllers, views, or front-end code. The "domain" is whatever happens to be in the database. Wrong because the rules are inaccessible to anything that isn't the UI. Fix: extract a real domain layer. See ddd-design.
Big Ball of Mud. No boundaries at all. Everything reaches into everything. Wrong because change becomes impossible to localize. Fix: draw a context map first; integrate against the mud through an anticorruption layer; do not extend it. See ddd-bounded-context, ddd-context-mapping.
Cross-aggregate object references. Order holds an Customer object reference (not just an ID). Wrong because it forces eager loading, ties the two aggregates' lifecycles, and breaks the transactional boundary. Fix: hold an ID, look up via repository when needed. See ddd-aggregate.
Manager / Service / Helper suffix syndrome. Names like OrderManager, PaymentHelper, AccountProcessor hide the domain verb behind technical noise. Wrong because the ubiquitous language is supposed to live in the code. Fix: name for the verb the business uses. See ddd-ubiquitous-language, ddd-domain-service.
Decision heuristics
- If you can name a smell but can't name the target pattern, the smell is real but the fix is unclear. Discuss with the team and pick a target shape first, then refactor.
- Severity scales with reach: a leaky abstraction touched by ten callers is worse than the same leak in one place.
- Some anti-patterns are acceptable in generic subdomains (CRUD over a config table doesn't need a rich model). Don't apply DDD's full ceremony uniformly. See
ddd-subdomain-classification.
Anti-patterns about anti-patterns
- Treating every long class as anemic — anemia is about behavior, not length.
- Chasing patterns for the sake of patterns instead of fitness for purpose.
- Calling working, well-tested code "wrong" because it doesn't match a textbook layout.
- Renaming a
Managerto aServiceand calling it a refactor.
See also
- Every pattern skill in
ddd-core— each smell links to one or more of them. ddd-review— uses this catalog as its checklist.ddd-refactor— uses this catalog as its smell-to-target lookup.
References
- Evans, Domain-Driven Design (2003), Parts II and III.
- Fowler, Anemic Domain Model (essay, 2003) — the canonical statement of that anti-pattern.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/yonatankarp/software-design-skills/ddd-anti-patterns">View ddd-anti-patterns on skillZs</a>