architecture-patterns

Name: architecture-patterns
Availability: InStock
Author: leonardoteodoroo

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

Updated Feb 3, 2026

Search Tags:#architecture #backend #ddd #design-patterns #clean-architecture

Ready to run

npx skills add https://github.com/leonardoteodoroo/amino-advanced --skill architecture-patterns-leonardoteodoroo

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/leonardoteodoroo/amino-advanced/tree/main/.agent/skills/architecture-patterns
Command: npx skills add https://github.com/leonardoteodoroo/amino-advanced --skill architecture-patterns-leonardoteodoroo

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Fragmented backend designs and inconsistent architectural practices slow delivery and hinder maintainability. This Skill guides teams to adopt proven patterns (Clean Architecture, Hexagonal Architecture, and Domain-Driven Design) to create scalable, testable, and evolvable systems.

Core Features & Use Cases

Clean Architecture (Uncle Bob): separation of concerns with inward-focused dependencies across Entities, Use Cases, Interface Adapters, and Frameworks.
Hexagonal Architecture (Ports & Adapters): domain core decoupled from infrastructure via explicit ports and adapters.
Domain-Driven Design (DDD): strategic patterns (Bounded Contexts, Context Mapping) and tactical patterns (Entities, Value Objects, Aggregates, Repositories) to model complex domains.
Use cases include designing new systems from scratch, refactoring monoliths, establishing architectural standards, and migrating towards modular architectures.

Quick Start

Identify core domains and boundaries in your project, then implement Clean Architecture or Hexagonal Architecture to define clear layers and ports.

Frequently Asked Questions about architecture-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I design a scalable backend architecture for a new system?▼

Design scalable backend architecture by identifying core domains and boundaries, then applying Clean Architecture or Hexagonal Architecture to define clear layers, explicit ports, and adapters that decouple infrastructure from the domain core.

What is the best way to refactor a monolith into modular architecture?▼

Refactor monoliths into modular architecture by establishing explicit domain boundaries using Domain-Driven Design, applying strategic patterns like Bounded Contexts to isolate domains, and structuring interactions through ports and adapters.

How does Hexagonal Architecture decouple domain logic from infrastructure?▼

Hexagonal Architecture decouples domain logic from infrastructure by defining explicit ports and adapters, ensuring the domain core remains isolated and interacts with external systems only through these standardized connection points.

When should I use Domain-Driven Design tactical patterns in backend projects?▼

Use Domain-Driven Design tactical patterns like Entities, Value Objects, Aggregates, and Repositories when modeling complex domains, ensuring explicit domain boundaries, standardization, and readability across backend teams.

Clean Architecture vs Hexagonal Architecture for backend standardization?▼

Clean Architecture standardizes backend projects through inward-focused dependency separation across Entities and Use Cases, while Hexagonal Architecture achieves decoupling via explicit ports and adapters; both ensure evolvable, testable systems.

Do I need bounded contexts to establish architectural standards across teams?▼

Bounded contexts are required to establish architectural standards across teams because they define explicit domain boundaries, enabling consistent structure, naming, and interaction rules for scalable backend development.