SkillAgentSearch skills...

clean-architecture

Structure software around the Dependency Rule: source code dependencies point inward from frameworks to use cases to entities

Install / Use

npx skills add wondelai/skills --skill clean-architecture

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

87/100

Category

Operations

Supported Platforms

Universal

Our assessment of clean-architecture

clean-architecture scores 87/100 on our quality scale, 441st of 745 Operations skills we index.

Its SKILL.md is 16 KB long, well organised into 13 sections and no code examples: a thorough specification that gives an agent plenty to work with.

With 2,248 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
30/30
Structure
13/20
Description
15/15
Adoption
14/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so clean-architecture is actively maintained.
  • Our last check on 2026-11-02 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-29. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

clean-architecture compared with similar skills

All 4 of these similar skills score higher than clean-architecture; compare them before choosing.

SkillScoreStarsUpdatedFormat
clean-architecture (this skill)by wondelai872.2k2mo agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.md

Frequently asked questions

How do I install clean-architecture?
Run npx skills add wondelai/skills --skill clean-architecture. The install tabs above show the steps for each supported agent.
Which AI agents does clean-architecture work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is clean-architecture safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is clean-architecture still maintained?
The repository was last updated about 2 months ago, so clean-architecture is actively maintained.

name: clean-architecture description: 'Structure software around the Dependency Rule: source code dependencies point inward from frameworks to use cases to entities. Use when the user mentions "architecture layers", "dependency rule", "ports and adapters (hexagonal)", "onion architecture", "screaming architecture", "where should business logic go", "decouple from the database", "swap the framework without a rewrite", or "keep business rules independent". Also trigger when deciding which layer code belongs in, isolating core logic from infrastructure, defining module boundaries, or debating whether the framework should call your code or the reverse. Covers component principles, boundaries, and SOLID. For code-level quality, see clean-code. For domain modeling, see domain-driven-design.' license: MIT metadata: author: wondelai version: "1.4.0"

Clean Architecture Framework

A disciplined approach to structuring software so that business rules remain independent of frameworks, databases, and delivery mechanisms. Apply these principles when designing system architecture, reviewing module boundaries, or advising on dependency management.

Core Principle

Source code dependencies must point inward — toward higher-level policies. Nothing in an inner circle can know anything about an outer circle. This single rule produces systems that are testable and independent of frameworks, UI, database, and any external agency. Business rules are what matter; databases, web frameworks, and delivery mechanisms are details — when details depend on policies, you can defer decisions, swap implementations, and test business logic in isolation.

Scoring

Goal: 10/10. Score one point for each of the seven Quick Diagnostic rows the architecture satisfies (0-7), then map to a 0-10 band: 6-7 satisfied = 9-10 (Dependency Rule holds, business logic is framework- and DB-independent); 4-5 = 6-8 (core is testable but some details leak inward); 2-3 = 3-5 (framework or persistence dictates structure); 0-1 = 0-2 (no boundaries — business rules live in controllers and ORM models). Report the score, the failed diagnostic rows, and the specific inversion needed to fix each.

1. Dependency Rule and Concentric Circles

Core concept: Organize the architecture as concentric circles — Entities (enterprise business rules) innermost, then Use Cases (application business rules), then Interface Adapters, with Frameworks and Drivers outermost. Source code dependencies always point inward.

Why it works: When high-level policies don't depend on low-level details, you can swap the database, web framework, or API style without touching business logic — the system becomes resilient to the most volatile parts of the stack.

Key insights:

  • Inner circles cannot mention outer circle names — no classes, functions, variables, or data formats from outside
  • Data crossing a boundary must be in the form most convenient for the inner circle, never dictated by the outer
  • Dependency Inversion (interfaces defined inward, implemented outward) is the mechanism that enforces the rule
  • The number of circles is not fixed — four is typical; the rule stays the same
  • Frameworks are details, not architecture — they belong in the outermost circle

Code applications:

| Context | Pattern | Example | |---------|---------|---------| | Layer direction | Inner circles define interfaces; outer implement | UserRepository interface in Use Cases; PostgresUserRepository in Adapters | | Data crossing | DTOs cross boundaries, not ORM entities | Use Case returns UserResponse DTO, not an ActiveRecord model | | Dependency direction | Import arrows always point inward | Controller imports Use Case; Use Case never imports Controller |

See references/dependency-rule.md when an inner-circle import points outward and you need the four-circle code walkthrough, the data-crossing rules, and the four-step dependency-inversion procedure to fix it.

2. Entities and Use Cases

Core concept: Entities encapsulate enterprise-wide business rules — rules that would exist even without software. Use Cases contain application-specific rules that orchestrate the flow of data to and from Entities.

Why it works: Separating what the business does (Entities) from how the application orchestrates it (Use Cases) lets you reuse Entities across applications and change application behavior without altering core business rules.

Key insights:

  • Entities are not database rows — they are objects or pure functions encapsulating critical business rules
  • Use Cases accept Request Models and return Response Models — never framework objects
  • Each Use Case is a single application operation (CreateOrder, ApproveExpense)
  • The Interactor pattern: a Use Case class implements an input boundary interface and calls an output boundary interface
  • Changes to a Use Case should never affect an Entity; Entity changes may ripple to Use Cases

Code applications:

| Context | Pattern | Example | |---------|---------|---------| | Entity design | Critical business rules, zero framework dependencies | Order.calculateTotal() applies tax rules; knows nothing about HTTP | | Request/Response | Simple data structures cross the boundary | CreateOrderRequest { items, customerId } — no ORM models | | Single responsibility | One Use Case per operation | PlaceOrder, CancelOrder, RefundOrder as separate classes | | Interactor | Implements Input Port, calls Output Port | PlaceOrderInteractor implements PlaceOrderInput |

See references/entities-use-cases.md when designing an Interactor or deciding what belongs in an Entity versus a Use Case — full Enterprise vs. Application Business Rules treatment with request/response model examples.

3. Interface Adapters and Frameworks

Core concept: Interface Adapters convert data between the form convenient for Use Cases/Entities and the form required by external agencies. Frameworks and Drivers are the outermost layer — glue code to the outside world.

Why it works: When the web framework, ORM, or message queue is confined to the outer circles, replacing any of them is a localized change. The database is a detail; the web is a detail; details should be plugins to your business rules, not the skeleton of the application.

Key insights:

  • Controllers translate HTTP into Use Case input; Presenters translate Use Case output into view models
  • Gateways implement repository interfaces defined by Use Cases — the inner circle defines the contract, the outer fulfills it
  • Business rules never know whether data lives in SQL, NoSQL, or flat files, or that delivery is HTTP
  • Treat frameworks with suspicion — they want you to couple to them; keep them at arm's length

Code applications:

| Context | Pattern | Example | |---------|---------|---------| | Controller | Delivery mechanism → Use Case input | OrderController.create(req) builds CreateOrderRequest, calls Interactor | | Presenter | Use Case output → view model | OrderPresenter.present(response) formats for JSON/HTML | | Gateway | Repository interface implemented per DB | SqlOrderRepository implements OrderRepository | | Framework boundary | Framework calls inward, never the reverse | Express route handler calls Controller; Controller never imports Express |

See references/adapters-frameworks.md when wiring controllers, presenters, or gateways, or arguing that the database/web is a detail — covers plugin architecture and how to confine a framework to the edges.

4. Component Principles

Core concept: Components are the units of deployment. Three cohesion principles govern what goes inside a component; three coupling principles govern relationships between components.

Why it works: Poorly composed components create ripple effects where one change forces redeployment of unrelated code; the principles keep changes localized and releases independent.

Key insights:

  • REP (Reuse/Release Equivalence): classes in a component must be versionable and releasable as a unit
  • CCP (Common Closure): classes that change for the same reason at the same time belong together — SRP for components
  • CRP (Common Reuse): don't force users to depend on classes they don't use
  • ADP (Acyclic Dependencies): the component graph must have no cycles — break them with DIP or a new component
  • SDP (Stable Dependencies): depend in the direction of stability
  • SAP (Stable Abstractions): stable components should be abstract; unstable ones concrete

Code applications:

| Context | Pattern | Example | |---------|---------|---------| | Component grouping | Group classes that change together (CCP) | All order-related Use Cases in one component | | Breaking cycles | Apply DIP to invert a dependency edge | Extract an interface into a new component to break the cycle | | Stability metrics | Instability I = Ce / (Ca + Ce) | Many incoming, no outgoing deps → I near 0 (stable) |

See references/component-principles.md when grouping classes into deployable components or breaking a dependency cycle — each of REP, CCP, CRP, ADP, SDP, SAP worked through with the instability metric.

5. SOLID Principles

Core concept: Five class-and-module-level principles — Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion — the mid-level building blocks that make the Dependency Rule possible.

Why it works: Each principle addresses a specific way dependencies go wrong, preventing the rigidity, fragility, and immobility that turn codebases into legacy nightmares.

Key insights:

  • SRP: a module has one reason to change — it serves one actor (not "does one thing")
  • OCP: extend behavior by adding new code, not modifying existing code — strategy and plugin patterns
  • LSP: subtypes must be usable through the base interface without the client knowing — violated by unexpected exceptions or ignored methods
  • ISP: clients should not depend on methods they don't use — fat interfaces create needless coupling
  • DIP: high-level modules and low-level modules both depend on abstractions defined by the high-level module

Code applications:

| Context | Pattern | Example | |---------|---------|---------| | SRP violation | Class serves multiple actors | Employee handles pay (CFO), reporting (COO), persistence (CTO) | | OCP via strategy | New behavior through new classes | Add ExpressShipping implementing ShippingStrategy; Order untouched | | LSP violation | Subtype changes expected behavior | Square extends Rectangle breaks the setWidth()/setHeight() contract | | ISP application | Split fat interfaces into role interfaces | Printer, Scanner, Fax instead of one MultiFunctionDevice | | DIP wiring | High-level defines interface; low-level implements | OrderService depends on PaymentGateway, not StripeClient |

See references/solid-principles.md when applying SRP/OCP/LSP/ISP/DIP to a specific class or diagnosing a violation — each principle worked through with code examples and the smell it prevents.

6. Boundaries and Boundary Anatomy

Core concept: A boundary is a line between things that matter and things that are details, implemented through polymorphism: dependencies cross pointing inward while control flow may cross either way.

Why it works: Every boundary buys the option to defer a decision or swap an implementation; strategic boundary placement determines whether a system is a joy or a pain to maintain over years.

Key insights:

  • Full boundaries use reciprocal interfaces on both sides; partial boundaries use a simpler strategy or facade
  • Humble Object pattern: split boundary code into a hard-to-

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars2.2k
CategoryOperations
Updated2mo ago
Forks228

Languages

Shell

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

No cautions