solid

Apply SOLID principles to analyze and improve class and module boundaries.

Updated Jan 31, 2026
One-click install
npx skills add https://github.com/ddsyasas/pomodoro-app-shared --skill solid-ddsyasas
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: solid
Source: https://github.com/ddsyasas/pomodoro-app-shared/tree/main/pomodoro-app/.claude/skills/solid
Command: npx skills add https://github.com/ddsyasas/pomodoro-app-shared --skill solid-ddsyasas

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams apply SOLID design principles to class and module boundaries, improving maintainability, testability, and adaptability.

Core Features & Use Cases

  • SRP: Ensure a module has one reason to change by separating responsibilities.
  • OCP & ISP: Introduce abstractions and segregate interfaces to ease extension without modifying existing code.
  • LSP & DIP: Design subtypes that can substitute parent types and invert dependencies via abstractions.
  • Use cases include designing new classes, reviewing module boundaries, and refactoring legacy code to reduce coupling.

Quick Start

To start, identify a class with multiple responsibilities and apply SRP by extracting each responsibility into separate classes; introduce interfaces to invert dependencies and verify LSP compatibility.

Frequently Asked Questions about solid

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

FAQPage Schema
How do I apply SOLID design principles to refactor legacy object-oriented code?

To refactor legacy code with SOLID principles, identify classes with multiple responsibilities, extract each into separate modules, introduce abstractions to invert dependencies, and verify subtype compatibility to reduce coupling safely.

What is the Single Responsibility Principle in object-oriented design?

The Single Responsibility Principle ensures a module has one reason to change by separating distinct responsibilities into separate classes, improving maintainability and testability across the codebase.

How do I introduce abstractions and segregate interfaces to ease extension without modifying existing code?

Introduce abstractions and segregate interfaces by applying the Open-Closed and Interface Segregation Principles, allowing system extension through new implementations without altering existing source code.

Can I use SOLID principles for designing new classes and reviewing module boundaries?

SOLID principles are suited for designing new classes and reviewing module boundaries, targeting software design reviews by refining class structures and guiding safe refactoring strategies.

Why does my code break when substituting a subtype for its parent type?

Substitution failures occur when violating the Liskov Substitution Principle, meaning subtypes do not honor parent type contracts; design subtypes carefully to ensure they can fully substitute parent types.

Do I need external data or dependencies to analyze class boundaries using SOLID?

No external data or dependencies are required; analyzing class boundaries with SOLID principles relies solely on the existing codebase to identify responsibilities, craft abstractions, and guide refactoring.