clean-architecture

Structure software into decoupled layers with enforced dependency direction.

Updated Jan 12, 2026
One-click install
npx skills add https://github.com/cortezalberto/chile --skill clean-architecture-cortezalberto
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-architecture
Source: https://github.com/cortezalberto/chile/tree/main/.agents/skills/clean-architecture
Command: npx skills add https://github.com/cortezalberto/chile --skill clean-architecture-cortezalberto

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Clean Architecture provides a disciplined approach to organize software into concentric layers (domain, application, infrastructure) with clear boundaries and stable dependencies, reducing ripple effects of changes.

Core Features & Use Cases

  • Guidance on dependency direction, boundaries, entities, use cases, or system architecture.
  • Practical patterns for layering, adapters, gateways, mappers, and boundary definitions to improve testability and maintainability.
  • Use cases include designing new systems, reviewing code structure, and refactoring legacy apps.

Quick Start

Refactor a module by isolating domain, application, and infrastructure boundaries and wiring them via ports and adapters to enforce clean separation.

Frequently Asked Questions about clean-architecture

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

FAQPage Schema
How do I structure software with clean boundaries and decoupled layers?

Structure software with clean boundaries by organizing code into concentric layers—domain, application, and infrastructure—ensuring stable dependencies and reducing ripple effects from changes.

What is clean architecture and when should I apply it?

Clean architecture is a disciplined approach organizing software into concentric layers with clear boundaries. Apply it during design reviews, refactoring legacy apps, or planning new layered systems to improve maintainability.

How do I refactor a legacy module to enforce dependency direction and framework isolation?

Refactor a legacy module by isolating domain, application, and infrastructure boundaries, then wire them via ports and adapters to enforce clean separation and framework isolation within production code.

What's the best way to improve testability and maintainability in layered system architecture?

Improve testability and maintainability by applying practical patterns for layering, adapters, gateways, and mappers to define clear boundaries and enforce stable dependency direction across the system.

Can I use clean architecture patterns for designing new systems and reviewing code structure?

Yes, use clean architecture patterns for designing new systems, reviewing code structure, and refactoring legacy apps by enforcing dependency direction, boundary definition, and framework isolation.

Why does decoupled layer architecture reduce ripple effects when changing production code?

Decoupled layer architecture reduces ripple effects by enforcing stable dependency directions and clear boundaries between domain, application, and infrastructure layers, isolating changes within production code.