architecture-patterns

Architect backend systems using Clean, Hexagonal, and Domain-Driven Design patterns.

114|12|Updated Jan 22, 2026
One-click install
npx skills add https://github.com/OpenDCAI/leonai --skill architecture-patterns-opendcai
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/OpenDCAI/leonai/tree/main/.claude/skills/architecture-patterns
Command: npx skills add https://github.com/OpenDCAI/leonai --skill architecture-patterns-opendcai

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architect backend systems by applying proven patterns to improve maintainability, testability, and scalability across services.

Core Features & Use Cases

  • Clean Architecture: separate concerns with inward dependencies and framework-agnostic core.
  • Hexagonal Architecture: decouple domain logic from infrastructure via ports and adapters.
  • Domain-Driven Design: strategic and tactical patterns for modeling domains and aligning teams.
  • Use cases include designing new services from scratch, refactoring monoliths, and setting architectural standards for a large codebase.

Quick Start

Initialize a reference project skeleton that demonstrates Clean Architecture, Hexagonal Architecture, and DDD in a maintainable backend.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I apply Domain-Driven Design to decouple backend logic from infrastructure?

Apply Domain-Driven Design to decouple backend logic by using strategic and tactical patterns for modeling domains and aligning teams. This separates core concerns via ports and adapters, ensuring framework-agnostic maintainability and testability across services.

What is the best way to refactor a legacy monolith using clean architecture?

The best way to refactor a legacy monolith using clean architecture is to separate concerns with inward dependencies and a framework-agnostic core. This establishes a decoupled domain boundary, improving system maintainability and scalability during modernization.

When do I need hexagonal architecture for backend scalability?

You need hexagonal architecture for backend scalability when decoupling domain logic from infrastructure becomes critical. It uses ports and adapters to isolate core operations, ensuring systems remain testable and maintainable as infrastructure complexity grows.

How do I set architectural governance standards for a large codebase?

Set architectural governance standards for a large codebase by applying proven patterns like Clean Architecture and DDD. This enforces modularization, inward dependencies, and rigorous domain modeling to guide teams and maintain structural integrity.

Does clean architecture work with ports and adapters for new service design?

Clean architecture works seamlessly with ports and adapters for new service design by establishing inward dependencies and framework-agnostic cores. This combination decouples domain logic from infrastructure, satisfying strict requirements for testability and maintainability.