architecture-patterns

Apply SOLID, Dependency Inversion, and Clean Architecture to structure codebases with domain, application, and infrastructure layers.

7|Updated Jan 29, 2026
One-click install
npx skills add https://github.com/joabgonzalez/ai-agents-skills --skill architecture-patterns-joabgonzalez
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/joabgonzalez/ai-agents-skills/tree/main/skills/architecture-patterns
Command: npx skills add https://github.com/joabgonzalez/ai-agents-skills --skill architecture-patterns-joabgonzalez

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Guides teams to structure codebases for maintainability and scalability by applying SOLID, Dependency Inversion, Clean Architecture, Hexagonal patterns, and DDD.

Core Features & Use Cases

  • Structured layering guidance (Domain, Application, Infrastructure) with explicit boundaries.
  • Ports/Adapters approach enabling swappable implementations for testing and integration.
  • Practical frontend and backend examples, checklists, and references to support incremental adoption.

Quick Start

Use AGENTS.md signals and apply patterns to a new feature following the domain/application/infrastructure layering.

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 for complex domain logic using clean architecture?

Structure backend projects by enforcing Domain, Application, and Infrastructure layering with explicit boundaries. This clean architecture approach uses domain entities, use cases, and swappable adapters through ports and connectors to ensure maintainability and testability.

What is the difference between hexagonal architecture and DDD for software scalability?

Hexagonal architecture enables swappable implementations via ports and adapters for testing, while Domain-Driven Design focuses on modeling complex domain logic with domain entities and use cases. Both patterns combine to enforce consistent structure and naming for scalable applications.

When do I need SOLID principles and dependency inversion for my application?

You need SOLID principles and Dependency Inversion (DIP) when building large frontend apps or backend projects requiring layered organization, testability, and scalability. They enable swappable adapters and enforce separation between domain, application, and infrastructure layers.

How to apply domain-driven design patterns to a new feature incrementally?

Apply domain-driven design patterns to a new feature by following domain/application/infrastructure layering. Use AGENTS.md signals and practical checklists to guide incremental adoption of use cases, domain entities, and swappable adapters.

Does clean architecture work for large frontend applications or is it only for backend?

Clean architecture works for both large frontend applications and backend projects. It provides practical frontend examples and backend guidance for layered organization, ensuring testability, swappable adapters, and consistent structure across complex domain logic.

Why should I use ports and adapters instead of tightly coupled infrastructure code?

Use ports and adapters to enable swappable implementations for testing and integration. This hexagonal approach decouples infrastructure from domain logic, enforcing explicit boundaries and consistent structure while improving software maintainability and scalability.