clean-architecture

Structure software with inward-pointing dependencies separating Entities, Use Cases, Interface Adapters, and Frameworks.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Clean Architecture provides a disciplined way to structure software so that business rules remain independent of frameworks, databases, and delivery mechanisms, reducing coupling and improving testability over the long term.

Core Features & Use Cases

  • Defines concentric circles: Entities, Use Cases, Interface Adapters, and Frameworks, with dependencies pointing inward.
  • Provides boundaries, plug-in architecture, and guidelines for domain modeling, SOLID, and boundary anatomy.
  • Guides teams on how to test, evolve, and maintain long-lived software systems through modular boundaries.

Quick Start

Begin by identifying core entities and use cases, then define ports and adapters and wire them together in the composition root.

Frequently Asked Questions about clean-architecture

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

FAQPage Schema
What is clean architecture and how does it structure software dependencies?

Clean architecture structures software around inward-pointing dependencies across concentric circles—Entities, Use Cases, Interface Adapters, and Frameworks—to protect business rules from external changes. Dependencies point inward, keeping core logic independent of frameworks and databases.

How do I implement ports and adapters to decouple business logic from frameworks?

Implement ports and adapters by identifying core entities and use cases, defining interfaces, and wiring adapters together in the plugin-based Main composition root, allowing framework swapping without touching core logic.

When should I use clean architecture for my software project?

Use clean architecture for long-lived projects requiring clear boundaries between layers and high testability. It suits systems needing modular boundaries to evolve and maintain business rules independently from delivery mechanisms.

Does clean architecture enforce the dependency rule for SOLID principles?

Yes, clean architecture enforces the dependency rule to align with SOLID principles. It provides guidelines on boundary anatomy, ensuring dependencies point inward toward entities and use cases without circular references.

What are the limitations of structuring applications with clean architecture?

The limitations of clean architecture include increased initial complexity and boilerplate from strict boundary anatomy and port definitions. Smaller projects might find the overhead of separating Entities, Use Cases, and Interface Adapters unnecessary.