V3 DDD Architecture

Decomposes monolithic orchestrator code into DDD bounded contexts with clean architecture layers.

Updated Aug 18, 2026
One-click install
npx skills add https://github.com/wandreandrade2018-maker/claude-config --skill v3-ddd-architecture-wandreandrade2018-maker
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: V3 DDD Architecture
Source: https://github.com/wandreandrade2018-maker/claude-config/tree/main/.claude/skills/v3-ddd-architecture
Command: npx skills add https://github.com/wandreandrade2018-maker/claude-config --skill v3-ddd-architecture-wandreandrade2018-maker

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large TypeScript codebases often accumulate god objects—like a 1,440-line orchestrator handling tasks, sessions, health, and lifecycle all at once—making the code untestable and hard to extend. This Skill guides the decomposition of such monoliths into Domain-Driven Design bounded contexts with clean architecture and a microkernel plugin pattern. ## Core Features & Use Cases - Domain Decomposition: Splits god objects into focused bounded contexts (task management, session management, health monitoring, lifecycle, event coordination), each with entities, value objects, services, and repositories. - Microkernel & Plugin Architecture: Implements a core kernel that loads domains and supports optional plugins like swarm coordination with declared dependencies. - Event-Driven Integration: Defines domain events, event handlers, and an event bus for loose coupling between contexts, plus a phased migration plan with London School TDD testing. - Use Case: You inherit a claude-flow orchestrator that mixes five responsibilities in one file. Use this Skill to extract each responsibility into its own domain module, wire domain events, and reach over 90% domain logic test coverage. ## Quick Start Ask the AI to analyze the current orchestrator architecture and design DDD bounded contexts with clean interfaces and a migration plan.

Frequently Asked Questions about V3 DDD Architecture

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

FAQPage Schema
How do I break up a god object into DDD bounded contexts?

Identify the distinct responsibilities inside the god object, then extract each into its own domain module with entities, value objects, services, and a repository interface. Wire the domains together through domain events rather than direct calls to keep contexts independent.

What is the microkernel pattern in DDD architecture?

The microkernel pattern uses a small core kernel that loads domain modules at runtime and exposes them through a registry. Optional features like swarm coordination are implemented as plugins declaring their domain dependencies, keeping the core minimal and extensible.

How do bounded contexts communicate without tight coupling?

Bounded contexts communicate through domain events published on an event bus. When something like a task completion occurs, the originating domain emits an event and handlers in other domains react, so no context imports another's internals.

Does clean architecture require dependency injection in TypeScript?

Clean architecture requires the dependency rule—outer layers depend on inner layers, never the reverse—which in TypeScript is typically enforced with constructor injection of interfaces. Use cases receive repository and event bus abstractions rather than concrete infrastructure.

How do I test domain logic extracted from an orchestrator?

Test domain entities in isolation using London School TDD: instantiate the entity, mock collaborators like agents, invoke behavior, and assert state changes plus emitted domain events. Pure domain logic has no external dependencies, so tests need no database or network.