architecture-patterns

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

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/caraseli02/MoldovaDirect --skill architecture-patterns-caraseli02
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/caraseli02/MoldovaDirect/tree/main/.claude/skills/architecture-patterns
Command: npx skills add https://github.com/caraseli02/MoldovaDirect --skill architecture-patterns-caraseli02

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Architects and developers often struggle to structure backend code for maintainability, testability, and scalability across growing systems.

Core Features & Use Cases

  • Provides a structured approach to Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.
  • Establishes clear boundaries between domain logic, application rules, and infrastructure, enabling easier refactoring and onboarding.
  • Useful for designing new services, refactoring monoliths, and standardizing architecture across teams.

Quick Start

Organize your backend by separating domain logic, application rules, and adapters according to the patterns described.

Frequently Asked Questions about architecture-patterns

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

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

Apply Hexagonal Architecture and ports-and-adapters patterns to separate domain logic from infrastructure. This enforces inward dependencies and defines bounded contexts, making growing codebases easier to refactor and standardize.

When do I need to apply Hexagonal Architecture or ports-and-adapters in my backend?

You need to apply Hexagonal Architecture and ports-and-adapters when designing new services, refactoring monoliths, or standardizing architecture across a growing codebase to isolate domain logic from infrastructure changes and improve testability.

What is the best way to refactor a monolith to improve maintainability and testability?

The best way to refactor a monolith for maintainability and testability is applying Domain-Driven Design and Hexagonal Architecture to establish clear boundaries between domain logic, application rules, and infrastructure with well-defined ports and adapters.

Does Clean Architecture enforce inward dependencies for bounded contexts?

Yes, Clean Architecture enforces inward dependencies and well-defined bounded contexts. It separates domain entities, use cases, repositories, and gateways, ensuring infrastructure dependencies point inward toward the domain logic.

How do I separate domain logic from infrastructure when standardizing architecture across teams?

Separate domain logic from infrastructure by organizing backend systems into bounded contexts with clear ports and adapters. This isolates application rules and domain entities from infrastructure, enabling easier onboarding and standardization across teams.