architecture-patterns

Apply Clean Architecture, Hexagonal Architecture, and DDD to backend services.

2|2|Updated Jan 21, 2026
One-click install
npx skills add https://github.com/NorkzYT/claude-code-autopilot --skill architecture-patterns-norkzyt
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/NorkzYT/claude-code-autopilot/tree/main/.claude/skills/architecture-patterns
Command: npx skills add https://github.com/NorkzYT/claude-code-autopilot --skill architecture-patterns-norkzyt

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a structured approach to applying backend architecture patterns (Clean Architecture, Hexagonal Architecture, and Domain-Driven Design) to build maintainable, scalable systems. It helps teams establish clear boundaries, enforce dependency direction, and maintain testable core logic independent of frameworks.

Core Features & Use Cases

  • Structured Pattern Guidance: Learn and apply Clean Architecture, Hexagonal Architecture, and DDD to real projects.
  • Guided Refactoring & Architecture Standards: Use the patterns to decompose monoliths and set team-wide standards.
  • Use Case Examples: Design domain models, ports/adapters, and implementation layers for typical backend services.

Quick Start

Apply these patterns to a new or existing backend service by mapping domains, defining boundaries, and implementing ports/adapters to separate core logic from infrastructure.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I apply Domain-Driven Design to decompose a monolithic backend?

Apply Domain-Driven Design to decompose a monolithic backend by mapping domains, enforcing clear boundaries, and defining ports and adapters. This separates core domain logic from infrastructure, enabling maintainable and scalable refactoring.

What is the best way to structure a backend using clean architecture and hexagonal architecture?

Structure a backend using clean architecture and hexagonal architecture by implementing a framework-agnostic core, establishing ports and adapters, and enforcing strict dependency direction. This ensures testable core logic independent of external frameworks.

Can I use these architecture patterns for both new services and major refactoring projects?

Yes, these architecture patterns support projects ranging from new backend services to major monolith refactors. They provide structured guidance to establish clear boundaries, enforce dependency direction, and maintain scalable systems.

When do I need hexagonal architecture for a backend service?

You need hexagonal architecture when you must enforce domain boundaries and maintain a framework-agnostic core. It separates core logic from infrastructure using ports and adapters, ensuring testable and maintainable backend systems.

How do I enforce dependency direction in a backend architecture?

Enforce dependency direction in a backend architecture by applying clean architecture principles, isolating the framework-agnostic core, and implementing ports and adapters. This ensures infrastructure dependencies point inward toward the domain core.

Why does separating core logic from infrastructure improve backend maintainability?

Separating core logic from infrastructure improves backend maintainability by enforcing domain boundaries and framework-agnostic design. Using ports and adapters ensures testable core logic independent of external framework changes.