clean-architecture

Identify and apply Clean Architecture patterns to design maintainable software systems.

1|Updated Apr 13, 2026
One-click install
npx skills add https://github.com/OMIXEC/Mobile-dev-skills --skill clean-architecture-omixec
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-architecture
Source: https://github.com/OMIXEC/Mobile-dev-skills/tree/main/skills/clean-architecture
Command: npx skills add https://github.com/OMIXEC/Mobile-dev-skills --skill clean-architecture-omixec

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Provides a principled blueprint for designing software that remains understandable, testable, and adaptable by enforcing layered boundaries and stable abstractions.

Core Features & Use Cases

  • Clarifies the four-layer structure (domain, application, infrastructure, interface) and the Dependency Rule to reduce ripple changes.
  • Supplies practical patterns for entities, use cases, presenters, gateways, repositories, and data mappers to guide architecture reviews and refactoring.
  • Assists teams in evaluating and evolving codebases toward platform-agnostic designs with clear ownership and boundaries.

Quick Start

Identify a module and refactor it into domain, application, infrastructure, and interface layers, then isolate framework code behind abstractions to enable easy testing and future platform swaps.

Frequently Asked Questions about clean-architecture

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

FAQPage Schema
How do I structure my codebase using clean architecture and domain-driven design?

Clean architecture structures codebases into domain, application, infrastructure, and interface layers. This domain-centric design enforces the dependency rule, ensuring framework-specific code is isolated behind stable abstractions to reduce ripple changes.

How do I refactor a module to enforce dependency inversion between layers?

Refactoring for dependency inversion involves isolating framework code behind abstractions like gateways and repositories. This separates the domain and use-case logic from infrastructure, enabling easy testing and future platform swaps without altering core business rules.

What is the best way to define boundaries between domain logic and infrastructure code?

Defining boundaries requires applying the dependency rule so infrastructure depends on domain, never the reverse. Use patterns like entities, use cases, presenters, and data mappers to isolate framework-specific code and maintain a platform-agnostic core.

Can I use clean architecture patterns for reviewing code structure in an existing project?

Clean architecture patterns are effective for architecture reviews of existing projects. They provide a principled blueprint to evaluate codebases, clarify layered boundaries, and guide refactoring toward maintainable, testable, and adaptable software systems.

When do I need to isolate framework-specific code behind abstractions?

You need to isolate framework-specific code when pursuing a platform-agnostic design that allows easy testing and future platform swaps. Isolating frameworks behind abstractions ensures ripple changes in external libraries do not affect core domain and use-case layers.