My Favorite Skill is rick-rubin
The best code is the code you did not write. rick-rubin enforces that principle.
AI wants to help. Sometimes it helps too much.
You ask Claude to fix a bug. It fixes the bug. It also refactors the surrounding code. It adds error handling you didn't ask for. It improves the naming. It extracts a helper function. It updates the tests to match. Each change is reasonable in isolation. Together they create chaos.
This is scope creep. It happens constantly in agentic development. The agent sees opportunities for improvement everywhere. It acts on them. Your simple bug fix becomes a 400-line diff touching 12 files.
I named my solution after Rick Rubin.
The Philosophy
Rick Rubin is a music producer. He works by subtraction. His approach: remove everything that isn't essential. Strip the song down to its core. If it works in its simplest form, you've found the truth of it.
He describes it this way: "With the extra layers removed, you may stand back and notice that the work is successful in its simplest form."
This applies directly to software. The best code is the code you did not write. Every line is a liability. Every abstraction is complexity. Every "improvement" is a potential bug. Deletion is progress.
The Skill
rick-rubin is a skill that enforces scope discipline. It contains ten prompts for different situations. You pick one based on what you're doing.
The prompts come in pairs: moderate and aggressive. Moderate is the default. Aggressive is for when you've been burned before, when scope keeps creeping, when you need zero tolerance.
Starting a Project
Use Prompt B (Aggressive Scope Defense) when requirements are unclear.
The prompt forces you to produce:
- One-sentence project goal
- Hard exclusions (features not required)
- Dead weight list (unused docs, stale TODOs)
- Blocking ambiguities
- Minimal execution set for the next milestone
The rules are explicit: default action is delete, archive, or defer. No additions. No redesigns.
This prevents the common failure where projects accumulate speculative features before shipping anything. You start with the minimum. You ship the minimum. You add only what users actually need.
Implementing a Plan
Use Prompt D (Zero Tolerance Scope Lockdown) when executing from an existing plan.
The plan is a contract. Rules:
- No deviations
- No extra features, refactors, or generalization
- No cleanup unless explicitly required
- Make the smallest possible diff
- If ambiguity exists, proceed with the least-scope option
This is the prompt I use most often. Claude naturally wants to improve things. This prompt says: don't. Just do what the plan says. Nothing more.
Reviewing Code
Use Prompt F (Aggressive Scope Defense for Reviews) when reviewing someone's changes.
Assume all added behavior is unnecessary until proven required. No new features. No future-proofing. No stylistic refactors. No new abstractions.
For violations: exact code location, why it violates scope, minimal rollback or deletion.
This catches the "while I was in there" changes. The extra helper function nobody asked for. The configuration option for a scenario that doesn't exist. The abstraction layer that adds complexity without adding value.
Debugging
Use Prompt H (Reflection + Aggressive Scope Defense) when a bug keeps coming back.
The prompt identifies architectural decisions that enabled the bug. Concrete patterns and their failure modes. It does not propose fixes unless strictly necessary.
Sometimes the right answer is "this design is fundamentally broken" and the fix is a separate task. The prompt makes that explicit instead of letting the agent redesign everything in the middle of a bug fix.
Why It Works
The skill works because it's specific. It doesn't say "be careful about scope." It says exactly what to produce, exactly what rules to follow, exactly how to handle ambiguity.
Agents follow specific instructions better than general principles. "Prefer simplicity" is a principle. "Make the smallest possible diff" is an instruction. The skill is full of instructions.
The skill also works because it acknowledges context. Different situations need different levels of strictness. Starting a project needs exploration. Implementing a plan needs rigidity. Reviewing code needs skepticism. The ten prompts cover the common cases.
The Thesis
Scope discipline is the difference between shipping and not shipping. Every feature you don't build is a feature you don't maintain. Every line you don't write is a line that can't have bugs. Every abstraction you don't create is an abstraction nobody has to understand.
Rick Rubin strips songs down to their essence. rick-rubin strips software down to what it actually needs to do. Both produce better results through subtraction.
The best code is the code you did not write.