Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx skills add helmedeiros/clean-code-skills --skill oop-composition-over-inheritancegit clone --depth 1 https://github.com/helmedeiros/clean-code-skillsWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/helmedeiros/clean-code-skills/oop-composition-over-inheritance)<a href="https://agentmods.dev/skills/helmedeiros/clean-code-skills/oop-composition-over-inheritance"><img src="https://agentmods.dev/badge/skills/helmedeiros/clean-code-skills/oop-composition-over-inheritance.svg" alt="Measured on agentmods" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00048 | $0.00745 |
| Opus 5 | $0.00024 | $0.00373 |
| Sonnet 5 | $0.00010 | $0.00149 |
| Haiku 4.5 | $0.00005 | $0.00075 |
Grade A, and why
oop-composition-over-inheritance scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 7d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 80 lines — stays where its author put it; the contents beside it link to each section on GitHub.
OOP: Composition Over Inheritance
Favor object composition over class inheritance to achieve flexible, loosely coupled designs that combine behaviors without creating fragile hierarchies.
When This Skill Applies
- An inheritance hierarchy is deeper than 2-3 levels
- Subclasses override many parent methods or use only a fraction of inherited behavior
- A class needs to combine behaviors from multiple sources (multiple inheritance pressure)
- The user mentions composition over inheritance or the fragile base class problem
- Changing a base class breaks unexpected subclasses
Core Principle
Inheritance creates tight coupling between parent and child classes. Changes to the base class ripple through the entire hierarchy, often in unexpected ways (fragile base class problem). Composition assembles behavior from independent, interchangeable parts. Prefer "has-a" relationships over "is-a" relationships unless the is-a relationship is genuinely stable and permanent.
Workflow
Step 1: Identify the Hierarchy Problem
Check if the inheritance tree is deep (more than 2-3 levels), wide (many subclasses overriding different behaviors), or rigid (need to combine behaviors in ways the hierarchy does not support).
Step 2: Identify the Behaviors
List the distinct behaviors that vary across the hierarchy. Each behavior is a candidate for a separate component or strategy.
Step 3: Extract Behaviors into Components
Create a class or interface for each behavior. Move the behavior logic from the base class or subclass into the component.
Step 4: Compose at Runtime
The original class holds references to behavior components. Inject them via the constructor. Different combinations of components produce different behaviors without new subclasses.
Step 5: Verify
Ensure the composed behaviors work together. Run the test suite. Confirm that new behavior combinations do not require new classes.
Detection / Indicators
- Inheritance depth greater than 3 levels
- Subclasses that override most parent methods
- "Diamond problem" or desire for multiple inheritance
- Subclasses that use only a fraction of the parent's API
- Combinatorial explosion of subclasses:
FastRedCar,SlowRedCar,FastBlueCar... - Base class changes unexpectedly break distant subclasses
What ships with it
1 file beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 7d ago First seen · 80 lines · 48 tokens per session scan A a513a2cd33fe
oop-composition-over-inheritance is a skill published in the GitHub repository helmedeiros/clean-code-skills (2 stars, last pushed 6mo ago), licensed MIT. It adds 48 tokens to every session and 745 once invoked, about $0.0002 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.
Other skills, from other repositories
fp-brief
First-principles briefing from technical documents. Use when: understanding why decisions were made, onboarding to feature reasoning, reviewing decision chains, explaining doc from first principles. Not for: PM/CTO summary (use project-brief), pre-doc analysis (use feasibility-study), code explanation (use…
codex-explain
Explain complex code via Codex exec. Use when: understanding complex logic, tracing data flow, onboarding to unfamiliar code. Not for: code review (use codex-code-review), exploration (use code-explore). Output: structured explanation at chosen depth.
sharingan
Replicate knowledge from any source as sd0x-dev-flow skill definition. Use when: copying skills from repos, adapting patterns from articles/papers/code, converting knowledge to skill format. Not for: research without skill output (use deep-research), creating skills from scratch (use skill-creator), project onboarding…
creating-explainers
Use when creating an interactive explainer - a single self-contained HTML page with hand-built Canvas figures. Handles source-file explainers, topic-driven research explainers, and mixed intake where files provide the spine and research adds support. Trigger phrases include "make an explainer", "turn this paper into…
explaining-codebases
Use when creating an interactive explainer about a codebase, repository, or source files. Handles onboarding overviews, architecture maps, and deep-dives on real implementation paths. Trigger phrases include "explain this codebase", "interactive guide to this repo", "walk through how X works in the code", or…
openehr-assistant
This skill should be used when a conversation touches openEHR outside a task owned by a dedicated skill — e.g. "what is an archetype?", "how do openEHR templates work?", "which composition category fits this data?", "find me a guide on X", "where do I start with openEHR modeling?" — or names openEHR concepts (ADL…