CtrlK
BlogDocsLog inGet started
Tessl Logo

ddd-tactical-patterns

Apply DDD tactical patterns in code using entities, value objects, aggregates, repositories, and domain events with explicit invariants.

54

Quality

61%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

SecuritybySnyk

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./plugins/antigravity-bundle-ddd-evented-architecture/skills/ddd-tactical-patterns/SKILL.md

The canonical home for this skill is ddd-tactical-patterns in administrakt0r/AI-Agents-Safe-Coding-Skills

SKILL.md
Quality
Evals
Security

Quality

Content

57%Scale 1-5

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

The skill provides a reasonable overview of DDD tactical patterns with good scoping sections and one solid code example. However, it falls short on actionability by only demonstrating one pattern (aggregate invariant enforcement) while leaving value objects, repositories, and domain events as abstract bullet points. The workflow lacks validation steps and the referenced checklist file doesn't exist in the bundle.

Suggestions

Add concrete code examples for value objects, repository interfaces, and domain events—not just the aggregate pattern—to make the skill actionable across all claimed patterns.

Include a validation/verification step in the workflow, such as 'Run domain model tests to verify invariants hold' or a checklist for reviewing aggregate boundaries.

Either provide the referenced `references/tactical-checklist.md` file in the bundle or inline the essential checklist items directly in the skill.

Tighten the instructions from abstract principles ('Keep domain behavior in domain objects') into specific, executable guidance (e.g., show a before/after refactoring from anemic to rich model).

DimensionReasoningScore

Conciseness

Generally efficient and assumes Claude's competence with DDD concepts. The 'Use this skill when' and 'Do not use this skill when' sections add some bulk but are reasonable scoping. Minor verbosity in the Limitations section stating obvious negatives.

4 / 5

Actionability

The instructions are high-level principles rather than concrete, executable guidance. The TypeScript example is good and executable for one pattern (aggregate with invariant), but value objects, repositories, and domain events are only mentioned abstractly without concrete code examples. Key patterns are described rather than demonstrated.

3 / 5

Workflow Clarity

The five numbered steps provide a rough sequence for applying tactical patterns, but there are no validation checkpoints, no feedback loops for verifying that invariants are correctly modeled, and no explicit verification steps. For a skill involving refactoring and structural changes, the absence of validation guidance is notable.

3 / 5

Progressive Disclosure

References `references/tactical-checklist.md` for detailed checklists, which is good progressive disclosure intent. However, no bundle files are provided, so the reference is a dead link. The skill itself is reasonably structured with clear sections, but the single reference to a non-existent file weakens the score.

3 / 5

Total

13

/

20

Passed

Description

66%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.

The description clearly identifies the domain (DDD tactical patterns) and enumerates specific constructs, making it reasonably specific and distinctive. Its main weakness is the lack of an explicit 'Use when...' clause, which would help Claude know precisely when to select this skill over others. Adding trigger guidance and spelling out 'domain-driven design' would improve discoverability.

Suggestions

Add an explicit 'Use when...' clause, e.g., 'Use when the user asks about domain-driven design, modeling aggregates, defining bounded contexts, or implementing repository patterns.'

Spell out 'domain-driven design' alongside the abbreviation 'DDD' to capture users who use the full term.

Include related synonyms or adjacent concepts like 'aggregate root,' 'bounded context,' or 'ubiquitous language' to broaden trigger coverage.

DimensionReasoningScore

Specificity

Lists several specific DDD tactical patterns (entities, value objects, aggregates, repositories, domain events) and mentions 'explicit invariants.' This is fairly comprehensive but doesn't describe concrete coding actions like 'refactor anemic models' or 'define aggregate boundaries.'

4 / 5

Completeness

The 'what' is clear—apply DDD tactical patterns using specific constructs. However, there is no explicit 'when' clause (e.g., 'Use when...'). The absence of a 'Use when' clause caps this at 3 per the rubric guidelines.

3 / 5

Trigger Term Quality

Includes strong domain-specific trigger terms like 'DDD,' 'entities,' 'value objects,' 'aggregates,' 'repositories,' and 'domain events' that users familiar with DDD would naturally use. Missing some synonyms or related terms like 'domain-driven design' (spelled out), 'bounded context,' or 'aggregate root.'

4 / 5

Distinctiveness Conflict Risk

DDD tactical patterns form a fairly distinct niche that wouldn't easily overlap with generic coding or architecture skills. However, there could be minor overlap with broader software architecture or design pattern skills.

4 / 5

Total

15

/

20

Passed

Validation

90%

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

Validation10 / 11 Passed

Validation for skill structure

CriteriaDescriptionResult

frontmatter_unknown_keys

Unknown frontmatter key(s) found; consider removing or moving to metadata

Warning

Total

10

/

11

Passed

Repository
administrakt0r/AI-Agents-Safe-Coding-Skills
Reviewed

Table of Contents

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.