architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for backend systems.

Updated Dec 4, 2025
One-click install
npx skills add https://github.com/hiroto0701/dotfiles --skill architecture-patterns-hiroto0701
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/hiroto0701/dotfiles/tree/main/private_dot_claude/skills/architecture-patterns
Command: npx skills add https://github.com/hiroto0701/dotfiles --skill architecture-patterns-hiroto0701

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides a structured approach to designing and implementing complex backend systems, ensuring maintainability, testability, and scalability through established architectural patterns.

Core Features & Use Cases

  • Clean Architecture: Implement layered architecture for separation of concerns and dependency management.
  • Hexagonal Architecture: Utilize ports and adapters for technology-agnostic core logic.
  • Domain-Driven Design (DDD): Apply strategic and tactical patterns for complex domain modeling.
  • Use Case: Architecting a new e-commerce platform, refactoring a monolithic application into microservices, or establishing clear domain boundaries in a large enterprise system.

Quick Start

Implement a user entity with ID, email, and name using 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 apply Domain-Driven Design to define clear domain boundaries in a backend system?

Hexagonal architecture isolates core domain logic from external concerns using ports and adapters. This pattern ensures your backend design remains technology-agnostic, allowing you to swap databases or frameworks without modifying the core business rules.

What's the best way to refactor a monolithic application into microservices?

Refactoring a monolithic application into microservices requires establishing clear domain boundaries and enforcing dependency rules. Applying Clean Architecture or Hexagonal Architecture patterns helps separate concerns, allowing you to extract technology-agnostic core logic into independent services.

Does Clean Architecture enforce dependency rules for scalable backend design?

Clean Architecture enforces dependency rules through layered architecture, ensuring separation of concerns in backend design. By keeping the core logic independent of frameworks and databases, it builds maintainable, testable, and scalable applications for complex system design.

When do I need Hexagonal Architecture for my backend system?

You need Hexagonal Architecture when building complex backend systems that require technology-agnostic core logic and high testability. It uses ports and adapters to isolate your domain, making it ideal for new system design or monolithic refactoring where maintainability is critical.

How do I structure a user entity with ID, email, and name using Clean Architecture principles?

Structuring a user entity using Clean Architecture principles involves isolating ID, email, and name properties within the core domain layer. This ensures the entity remains independent of external frameworks and databases, enforcing strict dependency rules for maintainable backend design.