architecture-patterns

Architect backend systems with Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

1|Updated Apr 27, 2026
One-click install
npx skills add https://github.com/haxlys/skills --skill architecture-patterns-haxlys
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/haxlys/skills/tree/main/vendored/wshobson-agents/plugins/backend-development/skills/architecture-patterns
Command: npx skills add https://github.com/haxlys/skills --skill architecture-patterns-haxlys

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Architect backend systems using proven architectural patterns to create maintainable, scalable software.

Core Features & Use Cases

  • Proven patterns: Clean Architecture, Hexagonal Architecture, and Domain-Driven Design, with guidance on layering, dependencies, and boundaries.
  • Practical use cases: designing new services, refactoring monoliths, and debugging dependency cycles, establishing bounded contexts, and improving testability.
  • Reference architectures and best practices across multiple contexts, including ports/adapters, tactical patterns, and domain events.

Quick Start

Use these patterns to outline your service with layered architecture, ports and adapters, and bounded contexts.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I architect backend systems using Clean Architecture and Domain-Driven Design?

Architect backend systems by enforcing layer separation and explicit dependency rules. The Skill provides structured guidance for applying Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to establish clear boundaries and improve maintainability.

What is the best way to refactor a monolith into bounded contexts?

Refactor monoliths by establishing bounded contexts and enforcing layer separation across teams. It applies Domain-Driven Design principles to untangle dependencies, debug dependency cycles, and explicitly define boundaries for scalable software.

When do I need Hexagonal Architecture or ports and adapters in backend design?

You need Hexagonal Architecture and ports and adapters when designing new services that require high testability and strict dependency isolation. This pattern separates core logic from external infrastructure, enabling maintainable and scalable software.

Does this approach work for improving testability and debugging dependency cycles?

Yes, applying these architectural patterns directly improves testability and resolves dependency cycles. By enforcing explicit dependency rules and layer separation, the structured guidance isolates core logic from infrastructure to prevent circular dependencies.

How do I enforce layer separation and explicit dependency rules across teams?

Enforce layer separation and explicit dependency rules by applying structured architectural patterns like Clean Architecture and Domain-Driven Design. This establishes bounded contexts across teams, ensuring strict boundaries and preventing dependency cycles during service design.

What tactical patterns and domain events should I use for service design?

Use tactical patterns and domain events provided by reference architectures to design new services. The Skill outlines best practices for applying ports, adapters, and Domain-Driven Design concepts to structure your backend systems effectively.