skills.rest
garethdaine
garethdaineCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

solid-architecture

Enforce SOLID principles and composition patterns for maintainable code architecture.

Updated Feb 20, 2026
Search Tags:#code quality#architecture#refactoring#software design#maintainability#solid principles
One-click install
npx skills add https://github.com/garethdaine/agent --skill solid-architecture
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: solid-architecture
Source: https://github.com/garethdaine/agent/tree/main/.cursor/skills/solid-architecture
Command: npx skills add https://github.com/garethdaine/agent --skill solid-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill addresses the challenges of writing complex, hard-to-maintain, and brittle code by providing clear guidelines on software design principles and architectural patterns.

Core Features & Use Cases

  • SOLID Principles: Enforces Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
  • Composition Over Inheritance: Guides developers to favor composition for flexibility.
  • Module Organization: Provides best practices for file granularity, layering, and dependency management.
  • Side Effect Management: Helps in separating pure computation from impure operations and managing external interactions.
  • Use Case: When refactoring a large class with multiple responsibilities, this skill helps identify how to break it down into smaller, more manageable, and testable modules adhering to SRP.

Quick Start

Apply the SOLID principles to refactor the existing UserService class to improve its maintainability.

Frequently Asked Questions about solid-architecture

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

FAQPage Schema
How do I refactor a large class to improve code maintainability and testability?▼

Improve maintainability by breaking down large classes into smaller, testable modules using Single Responsibility and interface segregation, separating pure computation from impure side effects.

What are the SOLID principles in software design and how do they enforce separation of concerns?▼

SOLID principles are Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, which collectively enforce separation of concerns and robust application architecture.

Why should I favor composition over inheritance for software architecture?▼

Favor composition over inheritance to achieve greater flexibility in software architecture, allowing you to manage module organization and layering without rigid class hierarchies that make codebases brittle.

What is the best way to separate pure computation from impure side effects in a module?▼

Manage side effects by establishing clear boundaries that separate pure computation from impure operations, ensuring determinism and making external interactions easier to isolate and test.

Can I use these software design guidelines for refactoring any object-oriented codebase?▼

Yes, these guidelines apply to refactoring any object-oriented codebase because they enforce layering, interface segregation, and dependency inversion without requiring specific external dependencies.

Related Skills

Explore More Software Engineering Skills→
lrbjklrbjk

unity-project-scout

Assess Unity projects for version, render pipeline, packages, asmdefs, and folder structure.

Community
Intermediate
sehoon787sehoon787
16

swift-protocol-di-testing

Implement protocol-based dependency injection for testable Swift code.

Community
Advanced
anishi1222anishi1222

solid-check

Analyze source code for SOLID principle violations and refactoring suggestions.

Community
Basic
billybbuffumbillybbuffum

go-clean-architecture

Structure Go applications into domain, application, and infrastructure layers.

Community
Advanced