V3 DDD Architecture

Decomposes monolithic orchestrator code into bounded contexts using Domain-Driven Design patterns.

1|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/KentwareDemo/RuView --skill v3-ddd-architecture-kentwaredemo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: V3 DDD Architecture
Source: https://github.com/KentwareDemo/RuView/tree/main/.claude/skills/v3-ddd-architecture
Command: npx skills add https://github.com/KentwareDemo/RuView --skill v3-ddd-architecture-kentwaredemo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large TypeScript codebases often accumulate god objects—single files handling too many responsibilities—which makes code hard to test, maintain, and extend. This Skill guides the decomposition of a 1,440-line orchestrator into modular bounded contexts with clean architecture layers. ## Core Features & Use Cases - Domain Decomposition: Breaks god objects into focused domains like task management, session management, and health monitoring, each under 300 lines. - Microkernel & Plugin Architecture: Implements a core kernel that loads domains dynamically and supports optional plugins such as swarm coordination. - Event-Driven Communication: Defines domain events and handlers for loose coupling between bounded contexts. - Use Case: When refactoring a monolithic orchestrator.ts file, use this Skill to map bounded contexts, extract domain services in phases, and establish clean dependency-inverted interfaces with over 90% domain test coverage. ## Quick Start Ask the AI to analyze the current orchestrator architecture and design DDD bounded contexts with clean interfaces and domain events.

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 down a god object into DDD bounded contexts?

Identify the distinct responsibilities in the god object, then map each to a bounded context with its own entities, value objects, services, and repositories. Extract domains in phases, starting with the most independent responsibilities like task or session management.

What is the microkernel architecture pattern in TypeScript?

A microkernel is a minimal core that loads domains as pluggable modules at runtime. The kernel maintains a registry of domains, wires up domain events, and lets plugins declare dependencies on core domains like task-management and session-management.

How do bounded contexts communicate without tight coupling?

Bounded contexts communicate through domain events published to an event bus. Each context raises events like TaskCompletedEvent, and handlers in other contexts subscribe to them, keeping domains independent and loosely coupled.

Does clean architecture require dependency injection?

Clean architecture relies on dependency inversion, where outer layers depend on inner abstractions. Dependency injection containers wire concrete implementations like SqliteTaskRepository to domain interfaces, keeping the domain layer free of external dependencies.

What are the limitations of DDD for small projects?

DDD adds structural overhead with entities, value objects, repositories, and event handlers that may not pay off in small codebases. It is most valuable when decomposing large files with multiple responsibilities, such as a 1,400-line orchestrator.