architecture-patterns

Apply Clean Architecture, Hexagonal, and DDD patterns to backend systems.

Updated Jul 15, 2023
One-click install
npx skills add https://github.com/algusaem/algusaem-portfolio --skill architecture-patterns-algusaem
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/algusaem/algusaem-portfolio/tree/main/.claude/skills/architecture-patterns
Command: npx skills add https://github.com/algusaem/algusaem-portfolio --skill architecture-patterns-algusaem

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Designing backend systems with clear boundaries and maintainable structures can be challenging as codebases grow. This Skill teaches and applies proven patterns (Clean Architecture, Hexagonal Architecture, and Domain-Driven Design) to create scalable, testable, and adaptable architectures.

Core Features & Use Cases

  • Structured layering: separates business rules, use cases, adapters, and infrastructure to enable independent evolution.
  • Port and adapter discipline: establishes explicit interfaces for data access, messaging, and external services.
  • Domain-driven design guidance: uses bounded contexts, entities, value objects, and aggregates to model complex domains.
  • Use cases and refactoring scenarios: ideal for new systems, monolith decomposition, and architecture standardization across teams.

Quick Start

Start by mapping the current system into core domains and identify clear boundaries based on domain logic and external dependencies, then draft a Clean/Hexagonal/DDD-inspired structure.

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 backend system using Clean Architecture and DDD?

Apply Clean Architecture by separating business rules, use cases, adapters, and infrastructure into distinct layers, using bounded contexts and aggregates to model complex domains for scalable and testable architectures.

What is the best way to refactor a monolith into Hexagonal Architecture?

Refactor a monolith into Hexagonal Architecture by mapping the current system into core domains, identifying clear boundaries based on domain logic, and establishing explicit port and adapter interfaces for external dependencies.

When do I need ports and adapters in backend architecture?

Use ports and adapters in backend architecture when establishing explicit interfaces for data access, messaging, and external services, ensuring your core domain logic remains isolated and independently evolvable from external infrastructure.

Can I use Domain-Driven Design to establish team-wide architectural standards?

Yes, use Domain-Driven Design to establish team-wide architectural standards by applying bounded contexts, entities, value objects, and repositories to guide precise implementation and consistent structure across multiple projects.

How do I separate business rules from infrastructure in a scalable system?

Separate business rules from infrastructure in a scalable system by applying structured layering and port and adapter discipline, which isolates domain models and use cases to enable independent evolution of external dependencies.