skills.rest
NovusAevum
NovusAevumCOMMUNITY
Explore all skills by this author →
GitHub

architecture-patterns

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

1|Updated Nov 10, 2025
Search Tags:#system design#maintainability#domain-driven design#hexagonal architecture#clean architecture#software architecture#backend development
One-click install
npx skills add https://github.com/NovusAevum/dev-agents-orchestration --skill architecture-patterns-novusaevum
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/NovusAevum/dev-agents-orchestration/tree/main/configs/claude-code/skills/architecture-patterns
Command: npx skills add https://github.com/NovusAevum/dev-agents-orchestration --skill architecture-patterns-novusaevum

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill guides developers and architects in applying established backend architecture patterns (Clean Architecture, Hexagonal Architecture, Domain-Driven Design) to build scalable, testable, and maintainable software systems, preventing tightly coupled, fragile, and hard-to-change applications.

Core Features & Use Cases

  • Clean Architecture (Uncle Bob): Implements principles for framework-independent business logic, ensuring testability and clear separation of concerns.
  • Hexagonal Architecture (Ports & Adapters): Focuses on isolating the domain core from infrastructure, allowing easy swapping of database, UI, or external service implementations.
  • Domain-Driven Design (DDD): Applies strategic (Bounded Contexts, Context Mapping) and tactical (Entities, Value Objects, Aggregates, Repositories) patterns for modeling complex business domains.
  • Use Case: When refactoring a monolithic application or designing a new complex backend system, use this skill to decompose it into well-defined, loosely coupled layers and modules, making it easier to test, maintain, and evolve over time.

Quick Start

Design a new backend system using Clean Architecture principles for a user management service, outlining the layers and their responsibilities.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I design a backend system that's maintainable and testable?▼

Clean Architecture and Hexagonal Architecture separate business logic from infrastructure, enabling testability without external dependencies. They enforce inward-pointing dependencies and framework-agnostic core logic, making systems easier to modify and evolve over time.

What's the best way to refactor a monolithic application into loosely coupled layers?▼

Apply domain-driven design to decompose the monolith into bounded contexts and aggregates, then implement ports and adapters to isolate your domain core from databases, UI, and external services. This creates independently testable and replaceable modules.

How do I apply domain-driven design to model complex business domains?▼

Domain-driven design provides strategic patterns—bounded contexts and context mapping—and tactical patterns—entities, value objects, aggregates, and repositories—to structure code around business concepts, ensuring clarity and maintainability.

Can I use these architecture patterns to plan a microservices decomposition?▼

Yes. Clean Architecture and domain-driven design establish clear module boundaries and responsibility separation, which directly inform how to decompose a system into independent microservices with well-defined contracts and ownership.

Why should I separate my domain logic from infrastructure code?▼

Separating domain logic (ports and adapters, entities, use cases) from infrastructure (databases, frameworks) enables testing without external services, easier technology swaps, and code that remains valid as business requirements evolve independently of tech choices.

Related Skills

Explore More Software Engineering Skills→
nimadorostkarnimadorostkar
25

domain-modeling

Model domain concepts as explicit types with bounded contexts and invariants.

Community
Advanced
DexploarerDexploarer
7

microservices-orchestrator

Design microservices architectures with domain-driven bounded contexts and API contracts.

Community
Advanced
DVNghiemDVNghiem
20

clean-architecture

Apply Clean Architecture boundaries to isolate domain logic from infrastructure.

Community
Advanced
ekremmkasapekremmkasap

cqrs-implementation

Implement CQRS to separate write and read workloads for scalable systems.

Community
Advanced