architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design patterns.

1|Updated Feb 8, 2024
One-click install
npx skills add https://github.com/hokix/dotfiles --skill architecture-patterns-hokix
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/hokix/dotfiles/tree/main/ai/.agents/skills/architecture-patterns
Command: npx skills add https://github.com/hokix/dotfiles --skill architecture-patterns-hokix

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides guidance and implementation examples for complex backend architecture patterns, enabling the creation of maintainable, testable, and scalable systems.

Core Features & Use Cases

  • Pattern Implementation: Demonstrates Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD).
  • Guidance: Offers best practices and common pitfalls for each pattern.
  • Use Case: When architecting a new microservice, use this Skill to understand and apply Clean Architecture principles for a robust and decoupled design.

Quick Start

Use the architecture-patterns skill to generate a directory structure for a new Clean Architecture project.

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 project using Clean Architecture?

To structure a backend project using Clean Architecture, separate concerns into distinct layers with dependencies pointing inward toward the domain. This Skill generates directory structures and code examples to enforce decoupled, testable designs.

What is the difference between Hexagonal Architecture and Domain-Driven Design?

Hexagonal Architecture isolates domain logic from external interfaces through ports and adapters, while Domain-Driven Design focuses on modeling complex business domains. This Skill explains both patterns and provides best practices for applying them.

When should I use DDD in backend development?

Use Domain-Driven Design in backend development when building complex systems requiring scalable and maintainable domain modeling. This Skill provides implementation guidance to address separation of concerns and manage dependencies effectively.

How do I manage dependencies in a Hexagonal Architecture project?

Manage dependencies in a Hexagonal Architecture project by routing all dependencies toward the core domain, isolating it via ports and adapters. This Skill provides code examples for maintaining strict separation of concerns.

What are common pitfalls when implementing Clean Architecture?

Common pitfalls when implementing Clean Architecture include improper dependency management and blurred separation of concerns. This Skill highlights these architectural traps and offers best practices to ensure scalable backend systems.