software-design

Solid

Software design principles, patterns, and architecture from SOLID through distributed systems. Covers the five SOLID principles with violations and fixes, DRY/KISS/YAGNI heuristics, separation of concerns, 12 GoF design patterns organized by intent (creational, structural, behavioral), architectural patterns (MVC, MVP, MVVM, layered, hexagonal, microservices, event-driven), coupling and cohesion metrics, dependency injection, and the design decision framework for choosing between competing approaches. Use when making design decisions, reviewing architecture, refactoring code, or teaching software engineering principles.

AI & Automation 69 stars 9 forks Updated 1 weeks ago NOASSERTION

Install

View on GitHub

Quality Score: 79/100

Stars 20%
61
Recency 20%
90
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
50
License 10%
100
Description 5%
100

Skill Content

# Software Design Software design is the discipline of organizing code so that it is correct, understandable, and changeable. A well-designed system makes the right things easy and the wrong things hard. This skill catalogs the principles, patterns, and architectural styles that professional software engineers use to achieve this, with emphasis on when each applies and when it does not. **Agent affinity:** dijkstra (structured programming, formal reasoning about design), kay (OOP, message-passing architecture) **Concept IDs:** code-code-organization, code-abstraction, code-decomposition, code-peer-review ## Part 1 -- Design Principles ### The SOLID Principles Robert C. Martin codified these five principles for object-oriented design. They apply more broadly to any modular system. #### S -- Single Responsibility Principle (SRP) **Statement:** A module should have one, and only one, reason to change. **What it means.** Each class, function, or module should serve exactly one purpose. If you change the database schema, only the database layer should change. If you change the UI layout, only the UI layer should change. **Violation signal.** A class that has methods for both parsing user input AND writing to the database. A function that both validates data AND sends an email. **Fix.** Separate the responsibilities into distinct modules. A UserValidator validates; a UserRepository persists; an EmailService sends. #### O -- Open/Closed Principle (OCP) **Statement:** So...

Details

Author
Tibsfox
Repository
Tibsfox/gsd-skill-creator
Created
5 months ago
Last Updated
1 weeks ago
Language
TypeScript
License
NOASSERTION

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Listed

solid-principles

Apply the SOLID principles as design diagnostics when writing, reviewing, or refactoring code with classes, modules, or service boundaries - detecting god classes, fragile hierarchies, fat interfaces, and hard-wired dependencies, and prescribing the smallest structural fix. Treats SOLID as a smell detector, not a ceremony to impose. Use when designing a new module or class, reviewing object-oriented code, untangling a class that keeps changing for unrelated reasons, or deciding where an abstraction belongs.

4 Updated 5 days ago
KhaledSaeed18
Code & Development Listed

principle-solid

SOLID principles — SRP, OCP, LSP, ISP, DIP (single responsibility, open-closed, Liskov substitution, interface segregation, dependency inversion). Auto-load when designing classes, refactoring, reviewing object-oriented code, or discussing coupling, cohesion, abstractions, or any SOLID violation.

3 Updated yesterday
lugassawan
AI & Automation Solid

solidifier

Apply SOLID principles and design patterns to backend code with judgment and restraint. Use this skill whenever the user asks to refactor, review, clean up, restructure, or improve the design of backend code (services, APIs, domain logic, data access, handlers, jobs) — or mentions SOLID, design patterns, coupling, separation of concerns, testability, or "this code is hard to change/test." Also use when generating new backend modules that should be well-structured. Works in any backend language (Python, TypeScript/Node, Java, Go, C#, etc.). It scopes changes to specified parts of the codebase and reads a configurable rigor level so the depth of refactoring matches what the user wants.

35 Updated 1 weeks ago
FernandoJRR