1---2name: ddd3description: Domain-Driven Design - Modélisation métier et conception de domaines complexes. Utilise ce skill quand: (1) tu dois comprendre un domaine métier complexe, (2) tu veux identifier les bounded contexts d'un système, (3) tu dois créer un ubiquitous language partagé, (4) tu veux modéliser des entités et agrégats, (5) tu dois structurer du code selon Clean Architecture.4---56# Domain-Driven Design (DDD)78## Philosophie910Le DDD est une approche de conception logicielle qui place le **domaine métier au centre** de toutes les décisions. Ce skill guide la découverte, la modélisation et l'implémentation de domaines complexes.1112### Principes fondamentaux13141. **Le métier d'abord** : Le code doit refléter fidèlement le domaine métier152. **Langage ubiquitaire** : Un vocabulaire partagé entre développeurs et experts métier163. **Bounded Contexts** : Des frontières claires entre sous-domaines174. **Modèle riche** : La logique métier vit dans le domaine, pas dans les services1819### Ce que ce skill fait2021- Accompagne la découverte d'un domaine métier via Event Storming, Domain Storytelling, Example Mapping22- Aide à identifier et délimiter les Bounded Contexts23- Guide la création d'un Ubiquitous Language24- Modélise les Entities, Value Objects, Aggregates25- Structure le code selon Clean Architecture2627### Ce que ce skill NE fait PAS2829- Refactoring de legacy (→ skill dédié `legacy-modernization`)30- Implémentation technique bas niveau (→ `backend-developer`)31- Tests et validation (→ `testing-process`)32- Choix d'infrastructure (→ `devops`)3334---3536## Architecture du Skill3738```39ddd/40├── SKILL.md (ce fichier)41└── agents/42 ├── strategic/ # POURQUOI & QUOI - Niveau conceptuel (8 agents)43 │ ├── orchestrator.md44 │ ├── bounded-contexts.md45 │ ├── context-mapping.md46 │ ├── ubiquitous-language.md47 │ ├── core-domain-identification.md48 │ ├── event-storming.md49 │ ├── domain-storytelling.md50 │ └── example-mapping.md51 │52 ├── tactical/ # COMMENT - Niveau implémentation (17 agents)53 │ ├── orchestrator.md54 │ ├── entities.md55 │ ├── value-objects.md56 │ ├── aggregates.md57 │ ├── repositories.md58 │ ├── domain-services.md59 │ ├── domain-events.md60 │ ├── domain-errors.md61 │ ├── factories.md62 │ ├── specifications.md63 │ ├── domain-primitives.md64 │ ├── application-services.md65 │ ├── anti-corruption-layer.md66 │ ├── cqrs.md67 │ ├── event-sourcing.md68 │ ├── saga-process-manager.md69 │ └── clean-architecture.md70 │71 ├── tooling/ # OUTILS - Validation et qualité (3 agents)72 │ ├── model-validator.md73 │ ├── pattern-selector.md74 │ └── performance-guide.md75 │76 ├── templates/ # SCAFFOLDING - Templates de code (3 agents)77 │ ├── aggregate-template.md78 │ ├── value-object-template.md79 │ └── repository-template.md80 │81 ├── case-studies/ # EXEMPLES - Cas d'usage complets (2 agents)82 │ ├── e-commerce-domain.md83 │ └── anemic-to-rich-migration.md84 │85 └── integrations/ # INTÉGRATIONS - Frameworks (1 agent)86 └── nextjs-integration.md87```8889---9091## Domaines et Agents9293### Strategic (Niveau conceptuel) - 8 agents9495| Agent | Responsabilité |96|-------|----------------|97| `orchestrator` | Route vers l'agent strategic approprié |98| `bounded-contexts` | Identifier et délimiter les contextes bornés |99| `context-mapping` | Définir les relations entre contextes (Shared Kernel, ACL, etc.) |100| `ubiquitous-language` | Construire le vocabulaire partagé équipe/métier |101| `core-domain-identification` | Classifier Core / Supporting / Generic domains |102| `event-storming` | Faciliter les ateliers de découverte par événements |103| `domain-storytelling` | Narration visuelle des processus métier |104| `example-mapping` | Découverte par exemples et règles métier (Given-When-Then) |105106### Tactical (Niveau implémentation) - 17 agents107108| Agent | Responsabilité |109|-------|----------------|110| `orchestrator` | Route vers l'agent tactical approprié |111| `entities` | Modéliser les entités avec identité et comportement |112| `value-objects` | Créer des objets valeur immuables |113| `aggregates` | Définir les agrégats, racines et invariants |114| `repositories` | Concevoir les interfaces de persistance |115| `domain-services` | Implémenter la logique métier transverse |116| `domain-events` | Modéliser les événements du domaine |117| `domain-errors` | Gestion des erreurs métier typées (Result, Either) |118| `factories` | Encapsuler la création complexe d'agrégats |119| `specifications` | Règles métier composables et réutilisables |120| `domain-primitives` | Types primitifs typés (IDs, Email, Money...) |121| `application-services` | Use Cases et orchestration applicative |122| `anti-corruption-layer` | Protéger le domaine des modèles externes/legacy |123| `cqrs` | Séparer les modèles de lecture et d'écriture |124| `event-sourcing` | Stocker l'état comme séquence d'événements |125| `saga-process-manager` | Orchestrer les processus multi-agrégats longs |126| `clean-architecture` | Structurer le code en couches concentriques |127128### Tooling (Outils) - 3 agents129130| Agent | Responsabilité |131|-------|----------------|132| `model-validator` | Auditer un modèle DDD, détecter les anti-patterns |133| `pattern-selector` | Aider à choisir le bon pattern selon le contexte |134| `performance-guide` | Optimisation performance (snapshots, aggregate sizing) |135136### Templates (Scaffolding) - 3 agents137138| Agent | Responsabilité |139|-------|----------------|140| `aggregate-template` | Template complet pour créer un Aggregate |141| `value-object-template` | Templates de Value Objects (Money, Email, Address...) |142| `repository-template` | Template interface + implémentation Repository |143144### Case Studies (Exemples) - 2 agents145146| Agent | Responsabilité |147|-------|----------------|148| `e-commerce-domain` | Cas complet e-commerce (Event Storming → Code) |149| `anemic-to-rich-migration` | Guide migration modèle anémique → Rich Domain |150151### Integrations (Frameworks) - 1 agent152153| Agent | Responsabilité |154|-------|----------------|155| `nextjs-integration` | Intégration DDD avec Next.js App Router |156157---158159## Table de Routage160161### Routage Principal (Strategic vs Tactical)162163| Mots-clés | Domaine | Agent par défaut |164|-----------|---------|------------------|165| bounded context, sous-domaine, frontière, périmètre | strategic | bounded-contexts |166| context map, relation, upstream, downstream, ACL | strategic | context-mapping |167| vocabulaire, glossaire, terme, langage, ubiquitous | strategic | ubiquitous-language |168| core domain, supporting, generic, priorisation, valeur stratégique | strategic | core-domain-identification |169| event storming, atelier, sticky, événement métier | strategic | event-storming |170| storytelling, processus, narration, pictogramme | strategic | domain-storytelling |171| example mapping, user story, règle, exemple, cas limite | strategic | example-mapping |172| entity, entité, identité, cycle de vie | tactical | entities |173| value object, valeur, immuable, égalité structurelle | tactical | value-objects |174| aggregate, agrégat, racine, invariant, consistance | tactical | aggregates |175| repository, persistance, collection, stockage | tactical | repositories |176| domain service, service métier, logique transverse | tactical | domain-services |177| domain event, événement, notification, réaction | tactical | domain-events |178| factory, création, construction, instanciation | tactical | factories |179| specification, règle métier, critère, filtre, policy | tactical | specifications |180| domain primitive, type, typage, id, email, money | tactical | domain-primitives |181| application service, use case, command, query, orchestration | tactical | application-services |182| anti-corruption layer, ACL, legacy, traduction, isolation, externe | tactical | anti-corruption-layer |183| cqrs, command, query, read model, projection, séparation lecture écriture | tactical | cqrs |184| event sourcing, event store, replay, snapshot, historique, audit trail | tactical | event-sourcing |185| saga, process manager, compensation, transaction distribuée, workflow long | tactical | saga-process-manager |186| clean architecture, couche, layer, adapter, port | tactical | clean-architecture |187| error, exception, domain error, result, either, validation error | tactical | domain-errors |188| audit, validation, anti-pattern, qualité, review, santé modèle | tooling | model-validator |189| quel pattern, choisir, décision, trade-off, comparaison, recommandation | tooling | pattern-selector |190| performance, optimisation, snapshot, aggregate size, scaling | tooling | performance-guide |191| template, scaffolding, générer, boilerplate, starter | templates | aggregate-template |192| créer aggregate, structure aggregate | templates | aggregate-template |193| créer value object, template vo | templates | value-object-template |194| template repository, persistence, mapper | templates | repository-template |195| case study, exemple complet, end-to-end, e-commerce | case-studies | e-commerce-domain |196| migration, anemic, rich domain, refactoring legacy, strangler | case-studies | anemic-to-rich-migration |197| nextjs, next.js, app router, server actions, api routes | integrations | nextjs-integration |198199### Routage par Phase de Projet200201| Phase | Agents recommandés |202|-------|-------------------|203| Découverte initiale | event-storming → domain-storytelling → ubiquitous-language |204| Priorisation | core-domain-identification |205| Délimitation | bounded-contexts → context-mapping |206| Spécification | example-mapping → ubiquitous-language |207| Modélisation | domain-primitives → entities → value-objects → aggregates |208| Patterns de base | factories → specifications → domain-events |209| Architecture | clean-architecture → repositories → application-services |210| Patterns avancés | cqrs → event-sourcing → saga-process-manager |211| Intégration externe | anti-corruption-layer → context-mapping |212| Aide à la décision | pattern-selector |213| Audit & Qualité | model-validator |214215---216217## Workflow Recommandé218219```220┌─────────────────────────────────────────────────────────────────┐221│ DÉCOUVERTE │222│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │223│ │ Event │───▶│ Domain │───▶│ Example │ │224│ │ Storming │ │ Storytelling │ │ Mapping │ │225│ └─────────────┘ └──────────────┘ └─────────────────┘ │226└─────────────────────────────────────────────────────────────────┘227 │228 ▼229┌─────────────────────────────────────────────────────────────────┐230│ STRUCTURATION │231│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │232│ │ Bounded │───▶│ Context │───▶│ Ubiquitous │ │233│ │ Contexts │ │ Mapping │ │ Language │ │234│ └─────────────┘ └──────────────┘ └─────────────────┘ │235└─────────────────────────────────────────────────────────────────┘236 │237 ▼238┌─────────────────────────────────────────────────────────────────┐239│ MODÉLISATION │240│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │241│ │ Entities │───▶│ Value │───▶│ Aggregates │ │242│ │ │ │ Objects │ │ │ │243│ └─────────────┘ └──────────────┘ └─────────────────┘ │244└─────────────────────────────────────────────────────────────────┘245 │246 ▼247┌─────────────────────────────────────────────────────────────────┐248│ IMPLÉMENTATION │249│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │250│ │ Clean │───▶│ Repositories │───▶│ Domain │ │251│ │Architecture │ │ │ │ Services │ │252│ └─────────────┘ └──────────────┘ └─────────────────┘ │253└─────────────────────────────────────────────────────────────────┘254```255256---257258## Méthode de Découverte259260Quand un utilisateur demande de modéliser un domaine, proposer le choix :261262> **Quelle méthode de découverte préfères-tu ?**263> 1. **Event Storming** - Idéal pour découverte globale, équipes nombreuses264> 2. **Domain Storytelling** - Idéal pour communication avec métiers, documentation265> 3. **Example Mapping** - Idéal pour user stories, règles précises, cas limites266267---268269## Livrables270271| Livrable | Format | Agent source |272|----------|--------|--------------|273| Context Map | Diagramme Mermaid/PlantUML | context-mapping |274| Glossaire Ubiquitous Language | Markdown table | ubiquitous-language |275| Event Storming Board | Markdown structuré | event-storming |276| Modèle de domaine | Code + diagramme | aggregates |277| Structure Clean Architecture | Arborescence de dossiers | clean-architecture |278279---280281## Redirections vers autres Skills282283| Situation | Skill cible |284|-----------|-------------|285| Implémentation API/code détaillé | `backend-developer` |286| Tests unitaires/intégration | `testing-process` |287| Refactoring de legacy | `legacy-modernization` |288| Décisions d'infrastructure | `devops` |289| Architecture technique globale | `direction-technique` |290291---292293## Exemples d'Utilisation294295### Exemple 1 : Découverte d'un nouveau domaine296```297User: Je dois modéliser un système de réservation de salles298299DDD Skill:3001. Propose Event Storming pour découvrir les événements métier3012. Identifie les Bounded Contexts (Réservation, Salles, Utilisateurs, Facturation)3023. Construit le Context Map et l'Ubiquitous Language3034. Modélise les Aggregates (Reservation, Room, TimeSlot)304```305306### Exemple 2 : Modélisation tactique307```308User: Comment structurer mon agrégat Commande ?309310DDD Skill (tactical/aggregates):3111. Identifie la racine d'agrégat (Order)3122. Définit les entités enfants (OrderLine)3133. Crée les Value Objects (Money, Address, OrderStatus)3144. Établit les invariants métier3155. Propose la structure Clean Architecture316```
truchot