m09-domain

CRITICAL: Use for domain modeling. Triggers: domain model, DDD, domain-driven design, entity, value object, aggregate, repository pattern, business rules, validation, invariant, 领域模型, 领域驱动设计, 业务规则

Quality

68%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Fix and improve this skill with Tessl

tessl review fix ./skills/m09-domain/SKILL.md

Quality

Content

64%

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

This is a solid domain modeling reference skill with strong actionability through concrete Rust code examples and clear DDD-to-Rust mappings. Its main weaknesses are some redundancy between tables (Quick Reference vs Domain Concept table), the Trace Up/Down sections which add navigational complexity without bundle support, and the lack of validation checkpoints in the modeling workflow. Trimming duplicate content and adding a brief verification step would elevate this skill.

Suggestions

Merge the 'Domain Concept → Rust Pattern' table and 'Quick Reference' table into a single comprehensive table to eliminate redundancy.

Add a validation checkpoint to the Thinking Prompt workflow, e.g., 'Verify: Can this aggregate be persisted/loaded as a unit? If not, reconsider boundaries.'

Either provide the referenced bundle files (m01-ownership, m05-type-driven, m13-domain-error) or remove the Trace Up/Down sections to avoid dangling references.

Dimension	Reasoning	Score
Conciseness	The content is reasonably efficient but has some redundancy — the Quick Reference table largely duplicates the Domain Concept → Rust Pattern table, and the Trace Up/Trace Down sections add conceptual overhead that could be tightened. The 'Thinking Prompt' section explains concepts Claude already understands about DDD.	2 / 3
Actionability	The pattern templates provide fully executable Rust code for Value Objects, Entities, and Aggregates. The mapping tables give concrete, specific guidance on which Rust pattern to use for each DDD concept, and the Common Mistakes table provides actionable corrections.	3 / 3
Workflow Clarity	The 'Thinking Prompt' section provides a reasonable decision sequence for choosing domain patterns, but there are no validation checkpoints or feedback loops. For domain modeling decisions that affect system architecture, some verification step (e.g., 'validate aggregate boundaries by checking transactional consistency requirements') would strengthen the workflow.	2 / 3
Progressive Disclosure	The skill references related skills (m05-type-driven, m01-ownership, m13-domain-error, domain-*) but no bundle files are provided to support these references. The content itself is somewhat monolithic with multiple tables and code blocks that could benefit from better separation, though for a standalone skill the organization is adequate.	2 / 3
	Total	9 / 12 Passed

Description

72%

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 excels at trigger term coverage and distinctiveness, providing a comprehensive set of DDD-specific keywords including multilingual variants. However, it is weak on specificity of capabilities—it tells Claude to use it 'for domain modeling' but never explains what concrete actions the skill performs (e.g., designing aggregates, defining bounded contexts, implementing repositories). Adding explicit actions and a clearer 'Use when...' clause would significantly improve it.

Suggestions

Add concrete actions describing what the skill does, e.g., 'Designs aggregate roots, defines bounded contexts, models entities and value objects, implements repository patterns, and encodes business rules and invariants.'

Reframe the trigger list into a proper 'Use when...' clause, e.g., 'Use when the user asks about domain modeling, DDD patterns, aggregate design, or business rule validation.'

Dimension	Reasoning	Score
Specificity	The description names the domain (domain modeling, DDD) and mentions related concepts like entity, value object, aggregate, repository pattern, business rules, validation, and invariant. However, it does not list specific concrete actions (e.g., 'creates aggregate roots', 'defines bounded contexts', 'implements repository interfaces')—it only names concepts rather than describing what the skill actually does.	2 / 3
Completeness	The description has a 'Triggers' clause that serves as a partial 'when' indicator, and 'Use for domain modeling' addresses 'what' at a high level. However, the 'what' is very thin—it doesn't explain what the skill actually does beyond 'domain modeling.' The trigger list functions more as keyword matching than explicit guidance on when to use the skill.	2 / 3
Trigger Term Quality	Excellent coverage of natural trigger terms including both full phrases ('domain-driven design', 'domain model', 'repository pattern') and individual concepts ('entity', 'value object', 'aggregate', 'invariant', 'business rules', 'validation'). Also includes Chinese-language equivalents (领域模型, 领域驱动设计, 业务规则), which broadens coverage for multilingual users.	3 / 3
Distinctiveness Conflict Risk	Domain-driven design and domain modeling occupy a clear niche. The specific trigger terms like 'aggregate', 'value object', 'invariant', and 'repository pattern' are highly distinctive and unlikely to conflict with other skills such as general coding or database skills.	3 / 3
	Total	10 / 12 Passed

Validation

90%

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 — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: actionbook/rust-skills
Commit: fa60f79

Reviewed: 29 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.