m09-domain

Classify Rust domain concepts as Entity, Value Object, or Aggregate Root.

Updated Jan 21, 2026
One-click install
npx skills add https://github.com/lywa1998/self-host-claude-marketplace --skill m09-domain-lywa1998
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: m09-domain
Source: https://github.com/lywa1998/self-host-claude-marketplace/tree/main/plugins/rust-skills/skills/m09-domain
Command: npx skills add https://github.com/lywa1998/self-host-claude-marketplace --skill m09-domain-lywa1998

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers reason about domain concepts and decide the right Rust pattern (Entity, Value Object, Aggregate Root, Repository) before coding.

Core Features & Use Cases

  • Clarifies identity vs value semantics
  • Guides mapping to Domain patterns (Entity, Value Object, Aggregate Root, Repository)
  • Provides decision prompts for ownership and boundaries

Quick Start

Provide a clear classification of a given domain concept (e.g., User, Transaction) as Entity or Value Object, define its invariants, and suggest the appropriate Rust pattern and ownership model.

Frequently Asked Questions about m09-domain

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

FAQPage Schema
How do I decide if a Rust domain concept should be an Entity or a Value Object?

You decide if a Rust domain concept is an Entity or Value Object by clarifying identity versus value semantics. Entities maintain a distinct identity, whereas Value Objects are defined solely by their attribute values and are immutable.

How do I define aggregation boundaries and ownership semantics in Rust?

To define aggregation boundaries and ownership semantics in Rust, you apply domain-driven design decision prompts. This enforces aggregation boundaries and dictates the appropriate ownership model for your domain concepts.

What is the best way to map domain-driven design patterns to Rust?

The best way to map domain-driven design patterns to Rust is to classify your domain concept first. You then enforce identity rules and select the appropriate Rust pattern, such as Aggregate Root or Repository, to define invariants.

Can I use this approach for codebase architecture reviews in Rust?

Yes, you can use this approach for codebase architecture reviews in Rust. It evaluates existing domain concepts by enforcing identity rules, ownership semantics, and aggregation boundaries during the architecture review session.

When should I model a domain concept as an Aggregate Root in Rust?

You should model a domain concept as an Aggregate Root in Rust when it serves as a consistency boundary for a cluster of domain objects. This pattern enforces invariants and manages ownership semantics within its specific aggregation boundaries.