architecture-patterns

Master three foundational backend architecture approaches: Clean Architecture's layered dependency flow, Hexagonal Architecture's port-and-adapter model for technology independence, and Domain-Driven Design's strategic and tactical patterns for complex domains. Use this skill when designing new systems, refactoring monoliths, or establishing architecture standards for your team.

Architecture Patterns teaches Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for building maintainable backend systems.

AI-generated summary based on this skill's SKILL.md

★ 196 ⁮ 29 MIT updated 2026-07-25 by secondsky

Install

secondsky/claude-skills/architecture-patterns · repository language: TypeScript

Manual (git clone) CLI (skillfed)

git clone https://github.com/secondsky/claude-skills
cp -r claude-skills/plugins/architecture-patterns/skills/architecture-patterns ~/.claude/skills/architecture-patterns

npx skillfed install secondsky/claude-skills/architecture-patterns

Frequently asked questions

AI-generated answers based on this skill's SKILL.md and metadata

What is clean architecture pattern implementation in architecture-patterns?

architecture-patterns teaches Clean Architecture's layered dependency flow, where each layer (presentation, application, domain, infrastructure) has clear responsibilities and dependencies flow inward toward the domain core. This approach isolates business logic from frameworks and external concerns, making systems testable and maintainable. Use it when designing new systems or refactoring existing code to establish clear separation of concerns.

How does hexagonal architecture ports and adapters work?

Hexagonal Architecture in architecture-patterns uses a port-and-adapter model to decouple your core domain from external technologies. Ports define interfaces for external interactions (databases, APIs, UI), while adapters implement those interfaces for specific technologies. This technology-independent design lets you swap implementations without changing core logic, supporting easier testing and system evolution.

What domain driven design tactical patterns does architecture-patterns cover?

architecture-patterns covers DDD tactical patterns including value objects and entities for domain modeling, aggregate roots for transaction boundaries, repository patterns for data abstraction, and domain events for communicating state changes. These patterns help you model complex business domains accurately and maintain a ubiquitous language shared between technical and non-technical team members.

How can I refactor a monolithic application using these patterns?

architecture-patterns guides monolithic refactoring by first identifying bounded contexts and aggregate roots using DDD strategic patterns, then applying Clean Architecture layers to separate concerns, and using Hexagonal Architecture's ports to decouple from infrastructure. This staged approach reduces risk while improving testability and maintainability, preparing your codebase for potential microservices decomposition.

What makes architecture-patterns useful for establishing team standards?

architecture-patterns provides proven, language-agnostic patterns that teams can adopt as architecture standards. By teaching dependency inversion, loosely coupled design, and clear separation of concerns across Clean, Hexagonal, and DDD approaches, it gives your team a shared vocabulary and decision framework for designing scalable, maintainable systems consistently.

How does architecture-patterns support microservices decomposition?

architecture-patterns prepares you for microservices migration by teaching bounded contexts and context mapping from DDD, which identify natural service boundaries. Combined with Clean Architecture's layered design and Hexagonal Architecture's technology independence, you can decompose monoliths strategically, ensuring each service has clear responsibilities and minimal coupling.

SKILL.md

rendered from the published skill — quoted content, verbatim