evaluate-ddd

Files (1)

• SKILL.md

SKILL.md (first lines)

# DDD Evaluation

Shared files: a path written `@rules/…`, `@skills/…`, `@templates/…` or `@docs/…` is relative to the
plugin root, `${CLAUDE_PLUGIN_ROOT}` — not to the project being worked on. Read it from there.

**Usage:** `/architect:evaluate-ddd [target_path]`

## Desired Outcome

Quantitatively evaluate the target system's conformance to DDD principles across 3 layers and 12 criteria.

## Decision Criteria

For detailed scoring criteria, refer to:
@rules/evaluation-frameworks.md

- Strategic Design (30%): Ubiquitous language, bounded contexts, subdomain classification
- Tactical Design (45%): Value objects, entities, aggregates, repositories, domain services, domain events
- Architecture (25%): Layering, dependency direction, ports & adapters

## Prerequisites

| File | Required/Recommended | Source |
|------|---------------------|--------|
| reports/01_analysis/ | Required | /architect:analyze |

## Execution

### Step 1: Collect Input File Paths

Glob for all analysis documents: `reports/01_analysis/**/*.md`

Record the full list of found file paths — these will be passed to all sub-agents.

### Step 2: Spawn Three Parallel Layer Evaluators

In a **single message**, issue all three Agent() calls simultaneously so they run in parallel.
Each evaluator assesses its specific DDD layer independently.

**Task A — Strategic Design Layer (criteria 1-3)**
```
Agent(
  subagent_type: "general-purpose",
  model: "sonnet",
  description: "DDD strategic design layer evaluation",
  prompt: """
You are a DDD expert evaluating the STRATEGIC DESIGN layer (30% of total DDD score).

Read all analysis documents using the Read tool:
<FILE_LIST>
[Insert the full list of file paths found in Step 1, one per line]
</FILE_LIST>

Evaluate these 3 Strategic Design criteria, each scored 1-5:
(5=Exemplary, 4=Good, 3=Acceptable, 2=Concerning, 1=Critical)

1. **Ubiquitous Language**: Is domain terminology consistent between business and code? Are the same concepts named the same way everywhere?
2. **Bounded Context**: Are context boundaries clear with explicit responsibility separation? Is context mapping documented?
3. **Subdomain Classification**: Are Core/Supporting/Generic subdomains identified? Is investment level aligned with subdomain importance?

Return ONLY this JSON (no markdown fences, no explanation):
{
  "layer": "Strategic Design",
  "weight": 0.30,
  "criteria": [
    {
      "id": 1,
      "name": "Ubiquitous Language",
      "score": <integer 1-5>,
      "rationale": "<1-2 sentence explanation>",
      "findings": ["<specific issue or positive observation>"]
    },
    {
      "id": 2,
      "name": "Bounded Context",
      "score": <integer 1-5>,
      "rationale": "<1-2 sentence explanation>",
      "findings": ["<specific issue or positive observation>"]
    },
    {
      "id": 3,
      "name": "Subdomain Classification",
      "score": <integer 1-5>,
      "rationale": "<1-2 sentence explanation>",
      "findings": ["<specific issue or positive observation>"]
    }
  ],
  "layer_avg": <average of 3 scores, 1 decimal>,
  "layer_weighted_contribution": <layer_avg × 0.30, 2 decimals>
}
"""
)
```

**Task B — Tactical Design Layer (criteria 4-9)**
```
Agent(
  subagent_type: "general-purpose",
  model: "sonnet",
  description: "DDD tactical design layer evaluation",
  prompt: """
You are a DDD expert evaluating the TACTICAL DESIGN layer (45% of total DDD score).

Read all analysis documents using the Read tool:
<FILE_LIST>
[Insert the full list of file paths found in Step 1, one per line]
</FILE_LIST>

Evaluate these 6 Tactical Design criteria, each scored 1-5:
(5=Exemplary, 4=Good, 3=Acceptable, 2=Concerning, 1=Critical)

4. **Value Objects**: Are value objects immutable? Do they encapsulate domain rules? Are equality semantics value-based?
5. **Entities**: Do entities have stable identifiers? Is lifecycle management explicit?
6. **Aggregates**: Are transaction boundaries defined by aggregate roots? Are consistency invariants enforced within aggregates?
7. **Repositories**: Do repositories abstract persistence? Do they use collection semantics (not query-builder exposure)?
8. **Domain Services**: Are stateless cross-aggregate operations placed in domain services? Are they distinct from application services?
9. **Domain Events**: Are state changes published as domain events? Is event-driven design used for cross-context communication?

Return ONLY this JSON (no markdown fences, no explanation):

From wfukatsu/nexus-architect, MIT.

More from wfukatsu/nexus-architect