architecture-patterns

Guide backend architecture design using Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

Updated Feb 24, 2026
One-click install
npx skills add https://github.com/chicanoandres702/SentientAIBrowser --skill architecture-patterns-chicanoandres702
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/chicanoandres702/SentientAIBrowser/tree/main/.agents/workflows/architecture-patterns
Command: npx skills add https://github.com/chicanoandres702/SentientAIBrowser --skill architecture-patterns-chicanoandres702

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Designing robust backend architectures is hard; this Skill guides teams through proven patterns to create maintainable, scalable systems.

Core Features & Use Cases

  • Guidance on Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to structure codebases.
  • Practical directory structures and concrete examples to model architectural decisions.
  • Helpers for refactoring monoliths into modular, testable services and establishing architecture standards.

Quick Start

Run a design review workflow for an enterprise system and apply Clean Architecture, Hexagonal Architecture, and Domain-Driven Design principles.

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 codebase using Clean Architecture and DDD?

Structure a backend codebase using Clean Architecture and Domain-Driven Design by enforcing layered design and establishing clear boundaries between domain and infrastructure. This approach uses ports and adapters to separate core logic, ensuring your codebase remains maintainable and scalable.

What is the best way to refactor a monolith into modular, testable services?

Refactor a monolith by applying Hexagonal Architecture principles to isolate dependencies and establish clear architectural standards. This process transitions your application into modular, testable services by enforcing clear boundaries between the domain logic and infrastructure.

When do I need Hexagonal Architecture for my software design?

You need Hexagonal Architecture when building new services or refactoring monoliths that require strict separation of concerns. It enforces consistent use of ports and adapters, allowing you to swap infrastructure components without modifying the core domain logic.

Can I use this to establish architecture standards across multiple development teams?

Yes, you can establish architecture standards across teams by applying consistent use of ports and adapters alongside Domain-Driven Design. It provides practical directory structures and concrete examples to model architectural decisions uniformly.

How does the ports and adapters pattern work for backend design?

The ports and adapters pattern works by enforcing clear boundaries between your core domain and infrastructure in backend design. It defines specific entry and exit points for your application, allowing you to isolate business logic from external concerns like databases or APIs.