V3 DDD Architecture

Refactor monolithic TypeScript orchestrators into modular Domain-Driven Design architectures.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you eliminate a monolithic “god object” by restructuring your system into bounded domains using Domain-Driven Design, so responsibilities are separated, code is testable, and evolution is safer.

Core Features & Use Cases

  • Bounded Context Decomposition: Breaks an oversized core module (e.g., an orchestrator) into focused domains like task management, session management, and health monitoring.
  • Clean Architecture Layering: Organizes code by Presentation, Application, Domain, and Infrastructure to enforce dependency direction and reduce coupling.
  • Microkernel + Plugin Pattern: Establishes a kernel that loads core domains and supports optional domain plugins with explicit dependencies.
  • Domain Events for Integration: Uses domain events and handlers to coordinate cross-domain changes without direct dependencies.
  • Test-Ready Domain Interfaces: Defines entities, value objects, services, repositories, and event handlers so business logic can be validated independently.

Use case: When an orchestrator grows to 1,000+ lines, extract each responsibility into a bounded context, wire domain events between contexts, and expose application use cases that orchestrate transactions without mixing domain rules.

Quick Start

Use the skill to analyze your current orchestrator file, propose bounded-context boundaries, and generate a microkernel-based module layout with domain interfaces and event-driven integration.

Frequently Asked Questions about V3 DDD Architecture

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

FAQPage Schema
How do I refactor a monolithic orchestrator into bounded contexts using DDD?

To refactor a monolithic orchestrator into modular DDD domains, you decompose the god object into focused bounded contexts like task and session management. This skill generates domain interfaces, a microkernel core, and domain-event wiring to separate responsibilities.

What is the best way to break down a god object into modular domain-driven design domains?

The best way to break down a god object is applying clean architecture layering and a microkernel plugin pattern. You extract oversized core modules into independent domains, using domain events to coordinate cross-domain changes without creating direct dependencies.

When do I need to extract domain events and bounded contexts from a TypeScript backend?

You need to extract bounded contexts and domain events when a TypeScript backend orchestrator grows to 1,000+ lines and entangles task orchestration with health monitoring. This indicates responsibilities are coupled and require clean separation for safer evolution and independent testing.

Can I use a microkernel and plugin pattern to load bounded contexts in a clean architecture?

Yes, you can establish a microkernel core that loads core domains and supports optional domain plugins with explicit dependencies. This enforces clean architecture layering by organizing code into Presentation, Application, Domain, and Infrastructure layers to reduce coupling.

Does clean architecture layering work with domain events for cross-domain coordination in TypeScript?

Clean architecture layering works with domain events by using event handlers to coordinate cross-domain changes without direct dependencies. This allows application use cases to orchestrate transactions while keeping domain rules isolated and test-ready.

What are the limitations of refactoring an orchestrator into DDD bounded contexts?

A limitation of refactoring into DDD bounded contexts is the migration overhead of rewiring domain events and updating tests. This approach targets TypeScript backends and claude-flow v3 style systems, requiring careful boundary identification to avoid over-fragmenting domains.