skills.rest
Jimmy-Jung
Jimmy-JungCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

design-principles

Clarify object-oriented design principles and SOLID guidelines for class hierarchies.

Updated Aug 27, 2026
Search Tags:#architecture#refactoring#oop#design-principles#solid#class-diagram
One-click install
npx skills add https://github.com/Jimmy-Jung/claude_symbiote --skill design-principles-jimmy-jung
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: design-principles
Source: https://github.com/Jimmy-Jung/claude_symbiote/tree/main/.claude/skills/design-principles
Command: npx skills add https://github.com/Jimmy-Jung/claude_symbiote --skill design-principles-jimmy-jung

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Object-oriented design decisions often drift or become inconsistent across projects; this guide consolidates core principles and SOLID rules into a single, language-agnostic reference.

Core Features & Use Cases

  • Encapsulation and information hiding guidance for robust module boundaries.
  • Role-based collaboration and the "how" to structure objects without exposing internals.
  • Inheritance vs composition guidance, polymorphism, and class diagram conventions for scalable architectures.
  • Use Case: apply during architecture design or refactoring to align with SOLID principles and design patterns.

Quick Start

Apply this guide during a design review to refactor a class hierarchy toward SOLID compliance.

Frequently Asked Questions about design-principles

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 hierarchy?▼

Object-oriented design principles provide a language-agnostic baseline for establishing robust module boundaries, ensuring information hiding, and standardizing static structures to prevent inconsistent architectural drift across projects.

When do I need composition over inheritance in object-oriented architecture?▼

You need composition over inheritance during architecture design when you want to structure objects dynamically without exposing internals, avoiding rigid class hierarchies that violate SOLID guidelines and hinder scalable architecture.

How do I structure objects for role-based collaboration without exposing internals?▼

Structure objects by enforcing strict encapsulation and information hiding, defining robust module boundaries that allow objects to collaborate through roles while keeping their internal implementation completely hidden.

Does this SOLID design guide work for architecture reviews across different languages?▼

Yes, this guide unifies object-oriented design principles and SOLID rules into a single language-agnostic reference, making it suitable for architecture reviews and refactoring scenarios across any programming language.

What are the limitations of using class diagrams for SOLID compliance?▼

Class diagrams are limited to representing static structures, so they cannot capture dynamic runtime polymorphism or fully validate encapsulation, requiring additional design context to ensure complete SOLID compliance.

Related Skills

Explore More Software Engineering Skills→
ddsyasasddsyasas

solid

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

Community
Advanced
KaakatiKaakati
10

Ruby OOP Patterns

Generate Ruby 3.x class designs with SOLID principles and module mixins.

Community
Intermediate
causify-aicausify-ai
144

make_function_private

Rename unused Python functions and classes with leading underscores.

Official
Intermediate
ddsyasasddsyasas

components

Identify and enforce cohesive, decoupled component boundaries in software systems.

Community
Advanced