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
Decision gist · record as of 2026-07-25
Architecture Patterns teaches Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for building maintainable backend systems. 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.
Use it when
- Hexagonal Architecture in architecture-patterns uses a port-and-adapter model to decouple your core domain from external technologies.
- architecture-patterns covers DDD tactical patterns including value objects and entities for domain modeling.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
secondsky/claude-skills/architecture-patterns · repository language: TypeScript
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
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.
Architecture Patterns
Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.
When to Use This Skill
- Designing new backend systems from scratch
- Refactoring monolithic applications for better maintainability
- Establishing architecture standards for your team
- Migrating from tightly coupled to loosely coupled architectures
- Implementing domain-driven design principles
- Creating testable and mockable codebases
- Planning microservices decomposition
Core Concepts
1. Clean Architecture (Uncle Bob)
Layers (dependency flows inward): - Entities: Core business models - Use Cases: Application business rules - Interface Adapters: Controllers, presenters, gateways - Frameworks & Drivers: UI, database, external services
**Key
(truncated - see the full file via the links below)
File tree — 1 file
plugins/architecture-patterns/skills/architecture-patterns/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Learn and implement proven backend architecture patterns”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master three foundational backend architecture approaches—Clean Architecture, Hexagonal Architecture, and Domain-Driven Design—to structure systems for testability, maintainability, and scalability. Each pattern teaches dependency management, separation of concerns, and technology-agnostic core logic through practical examples and directory structures.
This skill guides you through building Spring Boot applications with clean architecture principles, ensuring domain logic stays independent of frameworks and infrastructure. Learn to structure layered packages, implement ports and adapters, apply domain-driven design tactical patterns, and maintain strict dependency rules that keep your codebase testable and maintainable.
Guides you through selecting the right architecture pattern—clean, hexagonal, feature-based, or vertical slice—based on team size and domain complexity. Covers folder structure, dependency inversion, module boundaries, and SOLID principles at application scale. Diagnoses architectural problems like fat controllers and circular dependencies.
Master the Ports & Adapters pattern to isolate business logic from frameworks and infrastructure. This skill covers domain modeling, use-case orchestration, inbound and outbound port design, adapter implementation, and composition wiring across multiple languages.
Systematically explores your codebase to identify shallow modules and coupling friction, then frames the problem space and generates multiple interface design proposals via parallel sub-agents. Compares alternatives and files the recommended refactor as a GitHub issue RFC, grounding each suggestion in actual call patterns and dependency boundaries.
This skill teaches you to thoroughly test domain layer code using pytest, covering value object validation and immutability, entity identity and business logic, and domain invariants. Learn patterns for reaching 95%+ coverage on pure domain models without external dependencies or mocks.
More skills architecture-patterns (MIT) · microservices-patterns (MIT)