software-design-philosophy

Reviews module designs and APIs for complexity using deep-module and information-hiding principles.

Updated Jul 8, 2026
One-click install
npx skills add https://github.com/HafidJoss/Lummy --skill software-design-philosophy-hafidjoss
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: software-design-philosophy
Source: https://github.com/HafidJoss/Lummy/tree/main/agent/skills/software-design-philosophy
Command: npx skills add https://github.com/HafidJoss/Lummy --skill software-design-philosophy-hafidjoss

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Software systems accumulate complexity through hundreds of small design decisions, making code hard to understand, modify, and review. This Skill provides a structured framework, based on John Ousterhout's "A Philosophy of Software Design", to diagnose complexity symptoms, evaluate module depth, detect information leakage, and score designs against an eight-point diagnostic. ## Core Features & Use Cases - Design Scoring and Diagnostics: Score any module or API design out of 10 using eight diagnostic questions covering interface simplicity, information hiding, and documentation quality. - Complexity Red-Flag Detection: Identify classitis, temporal decomposition, pass-through methods, configuration-parameter overload, and back-door information leakage in existing code. - Design Review Guidance: Apply six principles (complexity causes, deep vs shallow modules, information hiding, general vs special-purpose interfaces, comments as design documentation, strategic vs tactical programming) when reviewing PRs or planning refactors. - Use Case: When reviewing a pull request that adds three new classes (RequestParser, RequestValidator, RequestProcessor), use this Skill to recognize classitis, explain why the modules are shallow, and recommend merging them into one deep RequestHandler. ## Quick Start Review this module's interface and score it against the software design philosophy diagnostic, listing which rows fail and what changes would fix them.

Frequently Asked Questions about software-design-philosophy

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

FAQPage Schema
How do I tell if a module is too shallow?

Compare the interface complexity to the functionality provided. If a method is harder to learn than to re-implement yourself, or a class only forwards calls to another class, the module is shallow and adds cognitive load without hiding meaningful complexity.

What is information leakage in software design?

Information leakage occurs when one design decision is reflected in multiple modules, so changing it requires editing all of them. Common forms include interface leakage, back-door leakage through shared data formats, temporal decomposition, and decorator patterns that duplicate wrapped interfaces.

When should I write comments in code?

Write comments for what code cannot express: design intent, abstraction contracts, invariants, and cross-module constraints. Interface comments are the most important type. Skip comments that merely restate what the code already makes obvious.

How much time should I spend on design versus shipping features?

The strategic programming approach recommends investing 10-20% of development time in design improvement as part of every change, not as separate refactoring phases. Small continuous improvements compound, while tactical shortcuts accumulate into crippling complexity.

Should I prefer general-purpose or special-purpose interfaces?

Aim for somewhat general-purpose: the simplest interface that covers all current needs. General interfaces are usually simpler than collections of special-case methods, but avoid speculative generality for hypothetical future requirements.

What are the limits of this design framework?

The framework provides qualitative heuristics rather than automated metrics, so scoring depends on judgment. It addresses module-level and interface design, not system-level architecture boundaries, which require separate architectural analysis.