architecture-patterns

Automate backend architecture decisions using Clean, Hexagonal, and Domain-Driven Design patterns.

4|Updated Mar 3, 2026
One-click install
npx skills add https://github.com/AI-Foundry-Core/ril-agents --skill architecture-patterns-ai-foundry-core
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-patterns
Source: https://github.com/AI-Foundry-Core/ril-agents/tree/main/plugins/backend-development/skills/architecture-patterns
Command: npx skills add https://github.com/AI-Foundry-Core/ril-agents --skill architecture-patterns-ai-foundry-core

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Architects and engineering teams struggle to maintain consistent backend architecture across systems, leading to brittle code, high maintenance costs, and inconsistent boundaries. This Skill provides a curated set of proven patterns to standardize architecture decisions and accelerate refactors.

Core Features & Use Cases

  • Standardized patterns for Clean, Hexagonal, and Domain-Driven Design to guide architecture decisions.
  • Guided refactoring paths and templates to improve maintainability and testability of large codebases.
  • Governance and communication facilitation by providing common terminology and reference guides.
  • Use Case Example: When upgrading a monolith to microservices, apply these patterns to define boundaries and adapters.

Quick Start

Use the reference guides and templates to begin structuring a scalable backend architecture today.

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 scalable backend using clean architecture and domain-driven design?

To structure a scalable backend using clean architecture and domain-driven design, this Skill provides standardized patterns that define layer separation, domain models, and ports and adapters to ensure consistent boundaries.

What is the best way to refactor a monolith into microservices with hexagonal architecture?

Refactoring a monolith into microservices with hexagonal architecture is guided by proven patterns and templates that define clear boundaries and adapters, accelerating the transition while improving maintainability and testability.

Can I use these architecture patterns to establish governance and common terminology across engineering teams?

Yes, you can use these architecture patterns to establish governance and common terminology across engineering teams by leveraging provided reference guides that standardize architecture decisions and facilitate communication.

When do I need domain-driven design patterns for my backend system?

You need domain-driven design patterns when struggling to maintain consistent backend architecture across systems, facing brittle code, high maintenance costs, or inconsistent boundaries that require standardized layer separation and domain models.

Does this hexagonal architecture guidance provide templates for implementing ports and adapters?

Yes, this hexagonal architecture guidance provides templates and reference guides for implementing ports and adapters, automating backend architecture decisions to standardize layer separation and leverage proven design patterns.