architecture-patterns
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.
Architecture Patterns teaches Clean, Hexagonal, and DDD approaches for building maintainable backend systems.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-22
Architecture Patterns teaches Clean, Hexagonal, and DDD approaches for building maintainable backend systems. 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.
Use it when
- architecture-patterns explains Hexagonal Architecture as a pattern where your application core (domain logic) connects to the outside world.
- architecture-patterns covers Domain-Driven Design (DDD) patterns including bounded contexts, aggregates, entities, and value objects.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Install
foryourhealth111-pixel/Vibe-Skills/architecture-patterns · repository language: Python
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
How do I structure backend code using clean architecture?
architecture-patterns teaches Clean Architecture by organizing code into concentric layers—entities, use cases, interface adapters, and frameworks—where dependencies point inward toward the domain core. This approach isolates business logic from infrastructure, making systems testable and maintainable. You'll learn practical directory structures and how to keep your backend independent of frameworks, databases, and UI concerns.
What are hexagonal architecture ports and adapters?
architecture-patterns explains Hexagonal Architecture as a pattern where your application core (domain logic) connects to the outside world through ports (interfaces) and adapters (implementations). Ports define contracts for external dependencies like databases or APIs; adapters implement those contracts. This design enables you to swap technologies without touching core logic, making your backend highly testable and loosely coupled.
How does domain-driven design structure backend systems?
architecture-patterns covers Domain-Driven Design (DDD) patterns including bounded contexts, aggregates, entities, and value objects. DDD aligns code structure with business domains, using rich domain models to encode business rules directly. You'll learn how to identify domain boundaries, model complex business logic, and organize microservices or monolithic systems around domain concepts rather than technical layers.
What's the difference between clean arch and hexagonal?
architecture-patterns clarifies that Clean Architecture and Hexagonal Architecture share the same core principle—isolating domain logic from external concerns—but emphasize different aspects. Clean Architecture focuses on layered dependency flow (inward-pointing); Hexagonal emphasizes symmetrical ports and adapters on all sides. Both achieve testability and maintainability; choose based on your team's mental model and system complexity.
How do I refactor a monolithic app using these patterns?
architecture-patterns guides refactoring by first identifying domain boundaries and separating business logic from infrastructure. Apply dependency inversion to decouple layers, introduce repository patterns for data access, and extract domain models. For microservices decomposition, use DDD bounded contexts to define service boundaries. Incremental refactoring—starting with high-value, loosely-coupled modules—reduces risk while improving testability.
What are value objects, entities, and aggregates in DDD?
architecture-patterns teaches that entities are domain objects with unique identities and lifecycles; value objects are immutable, identity-less objects representing domain concepts (like Money or Address); aggregates are clusters of entities and value objects treated as single units for consistency. These patterns help you build rich, expressive domain models that encode business rules directly, making backends more maintainable and aligned with domain language.
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 Principles:
-
(truncated - see the full file via the links below)
File tree — 1 file
bundled/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 clean, hexagonal, or DDD 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'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.
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.
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.
Architecture guides you through designing complete system architectures—from monolithic and microservices to event-driven and serverless approaches. It covers design patterns, quality attributes like performance and security, technology selection, and provides frameworks for documenting architectural decisions. Use it to evaluate trade-offs, plan scalability, and ensure your systems are maintainable and resilient.
Master RAG implementation through framework-specific patterns for LlamaIndex document processing, ChromaDB vector storage, and Celery task orchestration. This skill covers ingestion workflows, retrieval strategies, embeddings with circuit breakers, and performance optimization techniques.
Architecting Security guides strategic security design through defense-in-depth layering, zero trust implementation, and structured threat modeling. Map controls to NIST CSF, CIS Controls, and ISO 27001 for governance and compliance across greenfield systems, cloud migrations, and enterprise audits.
More skills social-media-api-integration (Apache-2.0) · ai-architect-expert (Apache-2.0) · web-scraping (MIT) · clean-architecture (MIT) · Python Backend Expert (unlicensed)