skills.rest
mrp4sten
mrp4stenCOMMUNITY
Explore all skills by this author →
GitHub

solid

Apply SOLID principles to class design and refactoring workflows.

3|Updated Apr 5, 2023
Search Tags:#architecture#refactoring#principles#oop#solid#design-patterns#software-design
One-click install
npx skills add https://github.com/mrp4sten/.dotfiles --skill solid-mrp4sten
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: solid
Source: https://github.com/mrp4sten/.dotfiles/tree/main/development/IA/opencode/skill/solid
Command: npx skills add https://github.com/mrp4sten/.dotfiles --skill solid-mrp4sten

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

SOLID principles help teams design maintainable, scalable object-oriented systems by clearly separating concerns and enabling safe evolution.

Core Features & Use Cases

  • Structured guidance on applying the five SOLID principles to real-world class design.
  • Refactoring help to split responsibilities and introduce abstractions.
  • Code-quality examples demonstrating proper composition vs inheritance in multiple languages.
  • Use case: when designing a new module or reviewing architecture, apply SRP, OCP, LSP, ISP, and DIP to improve maintainability and testability.

Quick Start

Apply SOLID principles to a sample class by identifying responsibilities, introducing abstractions, and refactoring toward single-responsibility components.

Frequently Asked Questions about solid

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

FAQPage Schema
How do I apply SOLID principles to refactor an existing class?▼

To apply SOLID principles during refactoring, identify existing responsibilities within a class, introduce abstractions for dependencies, and split logic toward single-responsibility components to improve maintainability and testability.

What is the best way to separate concerns when designing object-oriented systems?▼

Separating concerns in object-oriented systems is best achieved by applying SOLID principles, explicitly modularizing interfaces, and using composition over inheritance to enable safe system evolution.

Can I use SOLID design patterns across different programming languages?▼

Yes, SOLID design patterns are applicable across multiple object-oriented languages including Java, C#, TypeScript, and Python, providing structured guidance for real-world class design and architecture reviews.

Why does dependency inversion matter for scalable software architecture?▼

Dependency inversion matters for scalable software architecture because it forces modules to depend on abstractions rather than concrete implementations, enabling safe evolution and modular interfaces.

When do I need to refactor code using the Liskov Substitution Principle?▼

You need to refactor code using the Liskov Substitution Principle when derived classes alter the expected behavior of their base classes, ensuring proper inheritance hierarchies and preventing architectural violations.

Related Skills

Explore More Software Engineering Skills→
BikachBikach
12

backend-architect

Provide backend architecture guidance on hexagonal, DDD, SOLID, and clean code patterns.

Community
Advanced
amurataamurata
6

architecture-patterns

Implement Clean Architecture, Hexagonal Architecture, and Domain-Driven Design patterns.

Community
Advanced
Totes-MickGOATsTotes-MickGOATs
3

godot-composition

Enforce Composition over Inheritance for Godot entity design.

Community
Advanced
albibennialbibenni
2

quality-master

Audit source code for Clean Code and SOLID principle violations.

Community
Intermediate