architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design for backend systems.

Updated Mar 11, 2026
One-click install
npx skills add https://github.com/Industrial/rust-symphony --skill architecture-patterns-industrial
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/Industrial/rust-symphony/tree/main/.cursor/skills/architecture-patterns
Command: npx skills add https://github.com/Industrial/rust-symphony --skill architecture-patterns-industrial

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill provides guidance and implementation strategies for designing complex backend systems with a focus on maintainability, testability, and scalability using established architectural patterns.

Core Features & Use Cases

  • Pattern Implementation: Offers detailed guidance on Clean Architecture, Hexagonal Architecture, and Domain-Driven Design (DDD).
  • Refactoring & Design: Assists in architecting new systems or refactoring existing ones for better modularity and separation of concerns.
  • Use Case: When starting a new microservice that requires a clear separation between business logic and external dependencies, use this skill to establish a robust architectural foundation.

Quick Start

Use the architecture-patterns skill to design a new backend system using Clean Architecture principles.

Frequently Asked Questions about architecture-patterns

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

FAQPage Schema
How do I separate business logic from external dependencies in a new backend system?

You can separate business logic from external dependencies by implementing Clean Architecture and Hexagonal Architecture patterns, which use layered design and ports and adapters to isolate core domain rules from infrastructure.

What is the best way to architect a complex backend system for high maintainability and testability?

The best way to architect a complex backend system for maintainability and testability is by applying Domain-Driven Design alongside Hexagonal Architecture, ensuring strict separation of concerns and modularity through strategic and tactical domain modeling.

When do I need Domain-Driven Design for my software architecture?

You need Domain-Driven Design when architecting complex systems that require strategic and tactical domain modeling to handle intricate business rules, ensuring your backend architecture accurately reflects core domain logic.

How do I refactor an existing monolithic application into a modular architecture?

Refactor an existing monolithic application into a modular architecture by adopting Clean Architecture principles, migrating business logic into isolated layers, and implementing ports and adapters to decouple external dependencies.

Does this approach work for establishing the architecture of a new microservice?

Yes, this approach works for establishing the architecture of a new microservice by providing a robust architectural foundation that enforces separation between business logic and external dependencies through Hexagonal Architecture.

What is the difference between Clean Architecture and Hexagonal Architecture for backend development?

Clean Architecture focuses on layered design and dependency inversion for separation of concerns, while Hexagonal Architecture emphasizes ports and adapters to isolate application core logic from external interfaces in backend development.