clean-architecture-principles

Enforce clean-architecture principles with DRY, YAGNI, KISS, and Law of Demeter checks.

Updated Jul 29, 2025
One-click install
npx skills add https://github.com/T1nker-1220/.claude --skill clean-architecture-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: clean-architecture-principles
Source: https://github.com/T1nker-1220/.claude/tree/main/skills/clean-architecture-principles
Command: npx skills add https://github.com/T1nker-1220/.claude --skill clean-architecture-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill prevents over-engineered systems, unnecessary complexity, high coupling, and duplicated code, which often lead to unmaintainable and costly software.

Core Features & Use Cases

  • Enforce Core Principles: Guides you to apply DRY (Don't Repeat Yourself), YAGNI (You Ain't Gonna Need It), KISS (Keep It Simple, Stupid), Law of Demeter, and Separation of Concerns.
  • Complexity Warnings: Automatically warns when complexity creeps into designs or implementations, suggesting simpler alternatives and questioning speculative features.
  • Use Case: When designing a new feature or refactoring an existing module, activate this skill to ensure the proposed architecture is simple, maintainable, and adheres to established best practices.

Quick Start

Ask Claude to review your architectural design:

Review this architectural design for adherence to clean architecture principles.

// Example of simple function over complex abstraction
async function sendNotification(message: string, type: 'email' | 'sms') {
  if (type === 'email') {
    await emailService.send(message);
  } else {
    await smsService.send(message);
  }
}

Frequently Asked Questions about clean-architecture-principles

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

FAQPage Schema
How do I apply clean architecture principles to reduce code complexity?

Clean architecture principles like DRY, YAGNI, and KISS reduce complexity by eliminating duplication, avoiding speculative features, and keeping designs simple. This Skill enforces these principles during architecture design and refactoring, automatically warning when complexity creeps in and suggesting simpler alternatives to guide maintainable implementations.

What's the difference between DRY, YAGNI, and KISS in software design?

DRY (Don't Repeat Yourself) eliminates code duplication; YAGNI (You Ain't Gonna Need It) avoids building unused features; KISS (Keep It Simple, Stupid) favors straightforward solutions over complex ones. This Skill checks all three during code reviews and architectural discussions to prevent over-engineering and high coupling.

When should I review my architecture for design pattern violations?

Review your architecture during feature design, refactoring, or code reviews—especially when you notice rising complexity, multiple implementation approaches, or potential code duplication. This Skill detects Law of Demeter and Separation of Concerns violations, outputting standardized warnings to guide you toward clearer, more maintainable designs.

Can this help identify over-engineered features before they're built?

Yes. This Skill questions speculative features and warns when complexity grows unnecessarily, catching over-engineering early. Activate it during architectural discussions to catch feature creep and suggest simpler implementations that reduce maintenance costs.

Does this approach work for refactoring existing codebases?

Yes. This Skill is applicable during refactoring to enforce clean architecture principles on existing modules. It identifies violations of DRY, Separation of Concerns, and Law of Demeter, helping you simplify and decouple code incrementally.