architecture-patterns

Apply Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to backend systems.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Backend architecture design is often error-prone and time-consuming; this skill consolidates proven patterns (Clean Architecture, Hexagonal Architecture, and Domain-Driven Design) into a practical, reusable approach to structuring large systems.

Core Features & Use Cases

  • Provides a structured approach to applying Clean Architecture, Hexagonal Architecture, and Domain-Driven Design across services.
  • Demonstrates boundaries, ports and adapters, and dependency rules through concrete examples.
  • Supports designing bounded contexts, aggregates, and domain events to improve testability and maintainability.

Quick Start

Review your service boundary and begin applying the selected pattern to define clear boundaries and ports.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I apply Clean Architecture and Domain-Driven Design to structure backend services?

Use Hexagonal Architecture and ports-and-adapters to isolate domain logic from external interfaces. This pattern defines clear boundaries, ensuring dependencies point inward toward the domain, which improves system testability and maintainability.

When should I use Hexagonal Architecture versus Domain-Driven Design in my software?

Review your service boundary first, then apply the selected pattern to define clear boundaries and ports. Structure your domain logic, use cases, and adapters according to the dependency rules demonstrated through concrete examples to ensure reliable system evolution.

What are the dependency rules for defining boundaries in clean architecture?

You do not need any external dependencies to apply these backend architecture patterns. The approach consolidates Clean Architecture, Hexagonal Architecture, and Domain-Driven Design into a practical methodology focused on structuring domain logic and adapters within your services.

Does this approach support designing bounded contexts and domain events for microservices?

Limitations arise when applying these patterns to small services with minimal domain logic, as the overhead of defining bounded contexts, ports, and adapters outweighs maintainability benefits. Avoid forcing Clean Architecture or Domain-Driven Design when service boundaries are trivial and lack complex domain events.