skills.rest
tttol
tttolCOMMUNITY
Explore all skills by this author →
Website𝕏@tttol777GitHub

solid-principles

Apply SOLID design principles to refactor object-oriented codebases.

Updated Dec 14, 2024
Search Tags:#architecture#refactoring#principles#code-quality#oop#solid
One-click install
npx skills add https://github.com/tttol/dotfiles --skill solid-principles-tttol
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: solid-principles
Source: https://github.com/tttol/dotfiles/tree/main/config/skills/solid
Command: npx skills add https://github.com/tttol/dotfiles --skill solid-principles-tttol

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Improve software maintainability by applying SOLID design principles.

Core Features & Use Cases

  • Provides a structured interpretation of SRP, OCP, LSP, ISP, and DIP and how to apply them in real code.
  • Offers practical guidance for refactoring legacy code, designing clean interfaces, and building extensible architectures.
  • Includes checklists, examples, and references to deepen understanding and guide incremental improvements.

Quick Start

Identify a multi-responsibility class and refactor it into focused components following SRP, then apply the other SOLID patterns to improve design.

Frequently Asked Questions about solid-principles

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

FAQPage Schema
What are SOLID principles and how do they improve object-oriented code maintainability?▼

SOLID principles are five object-oriented design rules—SRP, OCP, LSP, ISP, and DIP—that improve software maintainability by enforcing structured requirements for clean interface design and extensible architecture decisions.

How do I refactor a multi-responsibility legacy class to follow SRP?▼

To refactor a legacy class for SRP, identify its multiple responsibilities and split it into focused components. This structured refactoring process isolates specific duties, improving code quality and preparing the codebase for applying other SOLID patterns.

Can I apply SOLID design principles to legacy C++ and C# codebases?▼

Yes, you can apply SOLID design principles to legacy C++ and C# codebases. The skill provides structured interpretation and practical guidance for refactoring object-oriented code across languages like Java, C#, and C++ to meet design quality goals.

What is the best way to design clean interfaces using ISP and DIP?▼

The best way to design clean interfaces using ISP and DIP is to follow structured patterns that separate interface responsibilities and invert dependencies. This builds extensible architectures by reducing coupling and enforcing specific design checkpoints.

When should I not use SOLID principles during software refactoring?▼

You should avoid over-applying SOLID principles when incremental refactoring is not feasible or when strict adherence to design patterns introduces unnecessary complexity for a simple object-oriented codebase, hindering practical code quality goals.

Related Skills

Explore More Software Engineering Skills→
sunLeeesunLeee

convention-solid-srp

Separate object-oriented class responsibilities to enforce the Single Responsibility Principle.

Community
Intermediate
iCesofTiCesofT
1

solid-principles

Apply SOLID design principles to Java codebases during code reviews and refactoring.

Community
Advanced
SzantoiSzantoi

dotnet-best-practices

Checks .NET/C# code quality and adherence to best practices and architecture patterns.

Community
Advanced
copyleftdevcopyleftdev

kay-inventing-the-future

Design software architectures using Alan Kay's message-passing and late binding principles.

Community
Advanced