architecture-patterns

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

2|Updated Mar 15, 2025
One-click install
npx skills add https://github.com/dandudzi/dotfiles --skill architecture-patterns-dandudzi
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/dandudzi/dotfiles/tree/main/dot_claude/skills/architecture-patterns
Command: npx skills add https://github.com/dandudzi/dotfiles --skill architecture-patterns-dandudzi

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a blueprint for designing and implementing scalable, maintainable, and testable backend systems by leveraging established architectural patterns.

Core Features & Use Cases

  • Clean Architecture: Enforces dependency rules for separation of concerns and testability.
  • Hexagonal Architecture: Decouples the core domain from external concerns via ports and adapters.
  • Domain-Driven Design (DDD): Focuses on modeling complex business domains with strategic and tactical patterns.
  • Use Case: When architecting a new e-commerce platform, use this Skill to structure the codebase around Clean Architecture principles, ensuring the domain logic remains independent of the chosen database or web framework.

Quick Start

Implement a user creation use case following Clean Architecture principles using the provided Python examples.

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 code using clean architecture principles?

Structure backend code using clean architecture by enforcing strict dependency rules to separate concerns, ensuring your core domain logic remains independent of external frameworks and databases for maximum testability.

What is the difference between hexagonal architecture and domain-driven design?

Hexagonal architecture decouples the core domain from external concerns via ports and adapters, while domain-driven design focuses on modeling complex business domains using strategic and tactical patterns for maintainable systems.

When should I use domain-driven design for microservice decomposition?

Use domain-driven design for microservice decomposition when you need to model complex business domains, enabling strategic and tactical patterns to cleanly separate bounded contexts and structure scalable backend systems.

How do I decouple database logic from domain models in Python?

Decouple database logic from domain models in Python by implementing hexagonal architecture with ports and adapters, decoupling the core domain from external concerns to ensure your business logic remains independent.

Can I use these architectural patterns to refactor a monolithic application?

Yes, you can use these architectural patterns to refactor a monolithic application by structuring your codebase with distinct layers, ports and adapters, and domain-centric modeling to achieve a scalable architecture.