architecture-patterns

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

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/ACGSpgp/ACGS --skill architecture-patterns-acgspgp
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/ACGSpgp/ACGS/tree/main/.agent/workflows/backend-development/1.2.3/skills/architecture-patterns
Command: npx skills add https://github.com/ACGSpgp/ACGS --skill architecture-patterns-acgspgp

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 foundational backend architecture patterns, enabling developers to build more maintainable, testable, and scalable systems.

Core Features & Use Cases

  • Clean Architecture: Implement layered architecture for separation of concerns and testability.
  • Hexagonal Architecture: Utilize ports and adapters for technology-agnostic core logic.
  • Domain-Driven Design (DDD): Apply strategic and tactical patterns for complex domain modeling.
  • Use Case: When starting a new complex backend project or refactoring a monolith, use this Skill to understand and apply Clean Architecture principles, ensuring a robust and maintainable foundation.

Quick Start

Implement the Clean Architecture pattern by structuring your project into domain, use_cases, and adapters layers.

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?

Hexagonal architecture isolates core business logic from external technologies using ports and adapters. This pattern makes your application's central domain completely technology-agnostic, allowing you to swap out databases or UI layers without modifying core logic.

When should I use Domain-Driven Design for backend development?

Yes, you can apply these architecture patterns when refactoring a monolithic backend. The Skill provides implementation guidance to break down monoliths into modular structures using Clean Architecture, ensuring a more maintainable and testable foundation.

What is the difference between Clean Architecture and Hexagonal Architecture?

If your backend domain logic is tightly coupled to frameworks or databases, Hexagonal Architecture decouples it using ports and adapters. This allows you to define clear boundaries, ensuring your core use cases remain independent of external infrastructure changes.

Why does my backend application lack testability and maintainability?

Your backend lacks testability because core logic is likely mixed with infrastructure code. Applying Clean Architecture separates these concerns into distinct layers, allowing you to unit test domain rules independently of databases or web frameworks.