architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design with Python examples.

3|2|Updated Aug 31, 2025
One-click install
npx skills add https://github.com/donggyun112/ai-librarian --skill architecture-patterns-donggyun112
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/donggyun112/ai-librarian/tree/main/.claude/skills/architecture-patterns
Command: npx skills add https://github.com/donggyun112/ai-librarian --skill architecture-patterns-donggyun112

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill addresses the challenge of designing and structuring complex backend systems to ensure maintainability, testability, and scalability by implementing established architectural patterns.

Core Features & Use Cases

  • Implement Clean Architecture: Organize code into distinct layers (Entities, Use Cases, Interface Adapters, Infrastructure) with strict dependency rules.
  • Apply Hexagonal Architecture: Decouple the core domain logic from external concerns using Ports and Adapters.
  • Leverage Domain-Driven Design (DDD): Model complex business domains effectively with concepts like Bounded Contexts, Entities, Value Objects, and Aggregates.
  • Use Case: When architecting a new microservice or refactoring a monolithic application, use this Skill to guide the project structure and ensure a clean separation of concerns, making future development and testing more efficient.

Quick Start

Use the architecture-patterns skill to generate a project structure for a new backend service 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 structure a Python backend using Clean Architecture and Domain-Driven Design?

To structure a Python backend using Clean Architecture and Domain-Driven Design, organize code into distinct layers like Entities, Use Cases, Interface Adapters, and Infrastructure with strict dependency rules for separation of concerns.

What is the best way to decouple domain logic from external concerns in a backend application?

The best way to decouple domain logic from external concerns in a backend application is applying Hexagonal Architecture, which uses Ports and Adapters to isolate the core domain and ensure maintainable, testable code.

When do I need Domain-Driven Design for complex system design?

You need Domain-Driven Design for complex system design when modeling intricate business domains, utilizing concepts like Bounded Contexts, Entities, Value Objects, and Aggregates to ensure effective domain modeling and scalable applications.

Can I use Hexagonal Architecture when refactoring a monolithic application to microservices?

Yes, you can use Hexagonal Architecture when refactoring a monolithic application to microservices to enforce clear separation of concerns, decouple core logic via Ports and Adapters, and make future development more efficient.

What are the limitations of enforcing strict dependency rules in software design?

Limitations of enforcing strict dependency rules in software design include potential architectural overhead and initial complexity, requiring careful modeling of entities, use cases, repositories, and adapters to ensure maintainability without excessive abstraction.