architecture-patterns

Generate layered and domain-driven backend architecture patterns with code samples.

Updated Feb 10, 2026
One-click install
npx skills add https://github.com/Mikisbell/HidroAliaga --skill architecture-patterns-mikisbell
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/Mikisbell/HidroAliaga/tree/main/.cursor/skills/architecture-patterns
Command: npx skills add https://github.com/Mikisbell/HidroAliaga --skill architecture-patterns-mikisbell

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill solves the common pain point of building backend systems that are tightly coupled, hard to test, and difficult to maintain as they scale, by providing standardized, proven architecture patterns that enforce clear separation of concerns and reduce technical debt.

Core Features & Use Cases

  • Multi-Pattern Coverage: Includes implementation guidance for Clean Architecture, Hexagonal Architecture, and Domain-Driven Design, the three most widely adopted backend architecture frameworks.
  • Practical Implementation Examples: Provides full, runnable code samples for each pattern, including domain entities, use cases, adapters, and repository implementations.
  • Real-World Use Case: A team building the HidroAliaga water distribution analysis backend can use these patterns to separate hydraulic calculation business logic from database and API concerns, making the core logic testable without external dependencies and easy to modify as regulatory requirements change.
  • Best Practices & Pitfalls: Includes actionable guidance on avoiding common mistakes like anemic domain models and framework coupling, plus checklists for adhering to core architecture principles.

Quick Start

Use the architecture-patterns skill to design the layered backend structure for the new water demand optimization module following Clean Architecture principles.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I decouple business logic from database and API frameworks in a backend system?

To decouple business logic, apply clean architecture principles using dependency inversion to isolate domain entities and use cases from external framework concerns, ensuring your core logic remains testable and framework-agnostic.

What is the best way to refactor a monolithic backend into maintainable domain-driven layers?

The best way to refactor a monolithic backend is to implement domain-driven design patterns, establishing clear bounded contexts and separation of concerns to decompose tightly coupled systems into maintainable, independent layers.

When should I use hexagonal architecture over clean architecture for my software design?

Use hexagonal architecture when you need strict isolation of core logic through ports and adapters, whereas clean architecture focuses broadly on dependency inversion layers; both achieve framework-agnostic, testable backend systems.

How do I avoid an anemic domain model when implementing domain-driven design?

To avoid an anemic domain model, encapsulate business behavior directly within domain entities instead of separating data and logic, ensuring your software design adheres to core domain-driven design principles.

Does clean architecture work for splitting a monolithic backend into microservices?

Yes, clean architecture works for microservices decomposition by enforcing clear separation of concerns and bounded contexts, allowing you to extract testable, framework-agnostic business logic into independent services.