solid-principles

Review code for SOLID design violations and suggest refactoring steps.

8|1|Updated Mar 28, 2026

Search Tags:#architecture #code review #refactoring #design patterns #clean code #solid

Ready to run

npx skills add https://github.com/bostonaholic/team --skill solid-principles-bostonaholic

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: solid-principles
Source: https://github.com/bostonaholic/team/tree/main/skills/solid-principles
Command: npx skills add https://github.com/bostonaholic/team --skill solid-principles-bostonaholic

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses technical debt and architectural fragility by providing a standardized framework for applying SOLID design principles during code creation and peer review.

Core Features & Use Cases

Architectural Guidance: Provides clear, actionable definitions for Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
Code Review Support: Offers specific checklists to identify design violations like fat interfaces, tight coupling, and improper dependency management.
Use Case: Use this skill during a code review to identify why a specific class violates the Single Responsibility Principle and receive suggestions on how to refactor it into smaller, more cohesive modules.

Quick Start

Ask the team to review the current module for SOLID design violations and suggest specific refactoring steps.

Frequently Asked Questions about solid-principles

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

FAQPage Schema

How do I identify SOLID design violations during a code review?▼

To identify SOLID design violations during a code review, apply a structured checklist to spot design smells like fat interfaces, tight coupling, and improper dependency management in object-oriented systems.

What is the best way to refactor a class that violates the Single Responsibility Principle?▼

The best way to refactor a Single Responsibility Principle violation is to split the bloated class into smaller, more cohesive modules. This refactoring strategy reduces technical debt and improves overall software maintainability.

How does Dependency Inversion improve clean code architecture?▼

Dependency Inversion improves clean code architecture by enforcing loose coupling between high-level and low-level modules through abstractions. This design principle prevents improper dependency management and reduces architectural fragility.

Can I use this SOLID methodology to review existing codebases for technical debt?▼

Yes, you can use this SOLID methodology to review existing codebases for technical debt. It provides actionable definitions for all five design principles to identify architectural fragility and suggest specific refactoring steps for complex systems.

When should I apply interface segregation to fix fat interfaces?▼

You should apply interface segregation to fix fat interfaces when a single contract forces classes to implement methods they do not use. This refactoring strategy splits bulky interfaces into cohesive, client-specific contracts to improve maintainability.