reducing-entropy — Claude Code skill: what it does, how to install
A skill that measures success by the size of the codebase afterwards, not by the effort spent. It runs only when you ask, and it deletes.
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a claude-codeWhat reducing-entropy does
The skill fires only when you call it by name. Success is the amount of code left at the end, not the work that went into getting there: 50 lines that remove 200 count as a win, keeping 14 functions to avoid writing 2 does not.
Before touching anything it loads one mindset from references/: lists the files, reads the frontmatter descriptions, picks one and states its core principle. Without that step it does not proceed. If the installed copy ships without the directory, the first step has nowhere to go, so check what the skill actually contains right after install.
Then come three questions. What is the smallest result that solves the problem? Does the change leave less total code, counted before and after? What can be deleted? The skill lists its own red flags: keeping what exists, adding flexibility, cleaner separation of concerns, type safety. It also says where it does not apply, such as a codebase already minimal, a framework with strong conventions, or a structure that compliance requires.
What it helps with
- delete a feature instead of wrapping it in flags
- count lines before and after a change and reject the version that grows
- find the code that a replacement made obsolete
- stop a refactor that adds files in the name of better structure
- collapse 14 functions into 2
Example prompts for the agent
- Run the reducing-entropy skill on `billing` and tell me what can be deleted
- Use reducing-entropy on this change: count the lines before and after
- Apply reducing-entropy here, drop the feature entirely if the codebase gets smaller
How to install reducing-entropy
1Skills CLI (Vercel)
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a claude-code2Manually: put the files in place
~/.claude/skills/reducing-entropy/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/reducing-entropy/
1Skills CLI (Vercel)
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a codex2Manually: put the files in place
.agents/skills/reducing-entropy/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a cursor2Manually: put the files in place
.cursor/skills/reducing-entropy/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install softaworks/agent-toolkit reducing-entropy2Manually: put the files in place
.github/skills/reducing-entropy/SKILL.md1Skills CLI (Vercel)
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a gemini-cli2Platform CLI
gemini skills install https://github.com/softaworks/agent-toolkit --path skills/reducing-entropyManually: put the files in place
.devin/skills/reducing-entropy/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add softaworks/agent-toolkit --skill reducing-entropy -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
From the same set3
The whole set →Similar
Questions about reducing-entropy
How do I install reducing-entropy in Claude Code?
Run npx skills add softaworks/agent-toolkit --skill reducing-entropy -a claude-code. The skill file ends up at ~/.claude/skills/reducing-entropy/SKILL.md.
What does reducing-entropy do?
It pushes the agent to compare total code before and after a change and reject anything that grows it. Every edit is treated as a chance to remove something else.
Why does it load a mindset from `references/` first?
The skill will not start until one mindset is loaded and its core principle named out loud. A missing directory therefore stops it before any edit.
Source text
SKILL.md · MIT
--- name: reducing-entropy description: Manual-only skill for minimizing total codebase size. Only activate when explicitly requested by user. Measures success by final code amount, not effort. Bias toward deletion. --- # Reducing Entropy More code begets more code. Entropy accumulates. This skill biases toward the smallest possible codebase. **Core question:** "What does the codebase look like *after*?" ## Before You Begin **Load at least one mindset from `references/`** 1. List the files in the reference directory 2. Read frontmatter descriptions to pick which applies 3. Load at least one 4. State which you loaded and its core principle **Do not proceed until you've done this.** ## The Goal The goal is **less total code in the final codebase** - not less code to write right now. - Writing 50 lines that delete 200 lines = net win - Keeping 14 functions to avoid writing 2 = net loss - "No churn" is not a goal. Less code is the goal. **Measure the end state, not the effort.** ## Three Questions ### 1. What's the smallest codebase that solves this? Not "what's the smallest change" - what's the smallest *result*. - Could this be 2 functions instead of 14? - Could this be 0 functions (delete the feature)? - What would we delete if we did this? ### 2. Does the proposed change result in less total code? Count lines before and after. If after > before, reject it. - "Better organized" but more code = more entropy - "More flexible" but more code = more entropy - "Cleaner separation" but more code = more entropy ### 3. What can we delete? Every change is an opportunity to delete. Ask: - What does this make obsolete? - What was only needed because of what we're replacing? - What's the maximum we could remove? ## Red Flags - **"Keep what exists"** - Status quo bias. The question is total code, not churn. - **"This adds flexibility"** - Flexibility for what? YAGNI. - **"Better separation of concerns"** - More files/functions = more code. Separation isn't free. - **"Type safety"** - Worth how many lines? Sometimes runtime checks in less code wins. - **"Easier to understand"** - 14 things are not easier than 2 things. ## When This Doesn't Apply - The codebase is already minimal for what it does - You're in a framework with strong conventions (don't fight it) - Regulatory/compliance requirements mandate certain structures ## Reference Mindsets See `references/` for philosophical grounding. To add new mindsets, see `adding-reference-mindsets.md`. --- **Bias toward deletion. Measure the end state.**
© softaworks · MIT · softaworks/agent-toolkit
