clean-architecture

Implements Clean Architecture pattern and Dependency Rule for modularizing business logic.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the common issue of tightly coupled codebases where business logic is inextricably linked to frameworks, databases, and UI, making systems fragile, difficult to test, and expensive to change.

Core Features & Use Cases

  • Dependency Management: Enforces the Dependency Rule, ensuring business rules remain independent of external details.
  • Architectural Diagnostics: Provides a scoring system to evaluate system boundaries, SOLID principle adherence, and component cohesion.
  • Use Case: Use this Skill when you need to decouple your core business logic from a specific web framework or database, or when you are designing module boundaries for a new microservice to ensure it remains a clean, testable unit.

Quick Start

Analyze the current project architecture and provide a score based on the seven Quick Diagnostic rows defined in the skill documentation.

Frequently Asked Questions about clean-architecture

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

FAQPage Schema
How do I decouple business logic from frameworks and databases in my system design?

To decouple business logic from infrastructure, apply the Clean Architecture pattern to strictly enforce the Dependency Rule, ensuring source code dependencies point exclusively inward toward higher-level policies and remain independent of external details.

What is the best way to evaluate system boundaries and SOLID principle adherence?

Evaluating system boundaries and SOLID principle adherence involves running an architectural diagnostic that scores component cohesion and dependency management based on seven Quick Diagnostic rows defined in the skill documentation.

How do I structure a new microservice to ensure long-term maintainability and testability?

Structure a new microservice for long-term maintainability by defining clear module boundaries and enforcing the Dependency Inversion principle, which separates core business rules from infrastructure to create clean, testable units.

Why does tightly coupled code make systems fragile and expensive to change?

Tightly coupled code makes systems fragile because business logic becomes inextricably linked to frameworks, databases, and UI, meaning any external change risks breaking core rules and significantly increases modification costs.

Can I use this architectural review approach on an existing web application with mixed dependencies?

Yes, you can use this approach on an existing web application by analyzing the current project architecture to identify where business rules violate the Dependency Rule, then refactoring to decouple core logic from specific frameworks.

When should I not use Clean Architecture for my software project?

You should avoid Clean Architecture when the system is too small to justify the overhead of strict module boundary definition and dependency inversion, as enforcing the Dependency Rule on trivial logic adds unnecessary complexity.