clean-ddd-hexagonal

Apply Clean Architecture, DDD tactical patterns, and Hexagonal Architecture to backend services.

58|3|Updated Jan 11, 2026
One-click install
npx skills add https://github.com/ccheney/robust-skills --skill clean-ddd-hexagonal-ccheney
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-ddd-hexagonal
Source: https://github.com/ccheney/robust-skills/tree/main/skills/clean-ddd-hexagonal
Command: npx skills add https://github.com/ccheney/robust-skills --skill clean-ddd-hexagonal-ccheney

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of designing scalable, maintainable, and testable backend services by providing a robust architectural blueprint. It helps teams avoid common pitfalls like anemic domain models, tight coupling, and difficult-to-test code.

Core Features & Use Cases

  • Architectural Guidance: Implements Clean Architecture, Domain-Driven Design (DDD) tactical patterns, and Hexagonal Architecture (Ports & Adapters).
  • Dependency Management: Enforces strict inward dependency rules, ensuring the core domain logic remains independent of infrastructure concerns.
  • Use Case: When designing a new e-commerce backend, use this Skill to structure the domain logic for orders, products, and customers, ensuring clear separation of concerns and enabling easy swapping of database technologies or API frameworks later.

Quick Start

Apply Clean Architecture + DDD + Hexagonal patterns to backend services.

Frequently Asked Questions about clean-ddd-hexagonal

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

FAQPage Schema
How do I build maintainable backend services using hexagonal architecture?

Hexagonal architecture builds maintainable backend services by enforcing strict inward dependency rules, isolating core domain logic from infrastructure concerns through defined ports and adapters. This separation ensures your business rules remain testable and independent of database or API framework choices.

What is the best way to structure complex domain logic in a backend system?

The best way to structure complex domain logic is applying Domain-Driven Design tactical patterns alongside Clean Architecture. This approach prevents anemic domain models by centralizing business rules, ensuring long-lived systems remain scalable and easily testable for large development teams.

How do I decouple domain logic from infrastructure in backend development?

Decouple domain logic from infrastructure by defining clear interfaces for ports and adapters in your backend development. This architectural blueprint enforces strict dependency management, allowing you to easily swap database technologies or API frameworks without modifying core business logic.

When do I need Clean Architecture and DDD tactical patterns for my backend?

You need Clean Architecture and DDD tactical patterns when designing complex business domains, long-lived systems, or working within large development teams. They address challenges like tight coupling and difficult-to-test code by providing a robust, language-agnostic structural blueprint.

Why does my backend service have an anemic domain model and tight coupling?

Anemic domain models and tight coupling occur when backend services lack strict architectural boundaries. Applying Clean Architecture and Hexagonal principles solves this by enforcing inward dependency rules, ensuring your domain logic stays robust, independent, and fully testable.