softaworks/agent-toolkit / skills/reducing-entropy
reducing-entropy
VerifiedManual-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.
| File | Kind | Size |
|---|---|---|
| README.md | markdown | 4.7 KB |
| SKILL.md | skill md | 2.5 KB |
| adding-reference-mindsets.md | markdown | 3.3 KB |
| references/data-over-abstractions.md | markdown | 1.8 KB |
| references/design-is-taking-apart.md | markdown | 2.2 KB |
| references/expensive-to-add-later.md | markdown | 2.4 KB |
| references/simplicity-vs-easy.md | markdown | 1.7 KB |
README.md
View on GitHub# Reducing Entropy
A manual-only skill for minimizing total codebase size by measuring success through final code amount, not effort. Biases toward deletion and aggressive simplification.
## Purpose
This skill exists to counter the natural tendency of codebases to grow over time. It provides a framework for evaluating changes based on whether they **reduce the total amount of code** in the final codebase, not just minimize the work required now.
More code creates more entropy. More entropy means more bugs, more maintenance, more cognitive load. This skill fights that trend.
## When to Use It
Use this skill when:
- Refactoring existing code and want to minimize the result
- Evaluating feature requests (should we add this?)
- Cleaning up technical debt
- Deciding between implementation approaches
- The user explicitly asks to "reduce entropy" or "minimize code"
- You need to bias toward deletion over addition
**Do NOT use automatically.** This is a manual-only skill that requires explicit user request.
## How It Works
### Core Philosophy
**Measure the end state, not the effort.**
- Writing 50 lines that delete 200 lines = net win (-150 lines)
- Keeping 14 functions to avoid writing 2 = net loss (+12 functions)
- "No churn" is not a goal. Less total code is the goal.
### The Three Questions
Every change must answer:
1. **What's the smallest codebase that solves this?**
- Not "smallest change" but smallest *result*
- Could this be 2 functions instead of 14?
- Could this be 0 functions (delete the feature)?
2. **Does this result in less total code?**
- Count lines/functions before vs. after
- If after > before, reject it
- "Better organized" but more code = more entropy
3. **What can we delete?**
- What does this make obsolete?
- What was only needed because of what we're replacing?
- What's the maximum we could remove?
### Reference Mindsets
Before starting, **you must load at least one mindset** from the `references/` directory. These provide philosophical grounding for radical simplification:
1. List files in `references/`
2. Read frontmatter to see which applies
3. Load at least one
4. State which you loaded and its core principle
**Do not proceed without loading a mindset.**
## Key Features
- **Deletion Bias**: Default action is to remove, not add
- **Total Code Metric**: Success measured by final codebase size
- **Anti-Pattern Detection**: Flags common excuses for adding code
- **Mindset-Driven**: Loads philosophical frameworks to guide decisions
- **Effort Agnostic**: Doesn't care about rewrite effort, only end result
## Red Flags
This skill actively rejects these common arguments:
| Argument | Why It's Rejected |
|----------|-------------------|
| "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 win. |
| "Easier to understand" | 14 things are not easier than 2 things. |
## When This Doesn't Apply
Don't use this skill when:
- The codebase is already minimal for what it does
- Working in a framework with strong conventions (don't fight it)
- Regulatory/compliance requirements mandate certain structures
- User wants to add functionality and accepts the code cost
## Usage Example
```
User: "I need to add validation to these 5 forms"
Standard approach:
- Create validation schema for each form (5 files)
- Add validation helper functions (1 file)
- Update each form component (5 files modified)
- Total: +6 files, ~300 lines added
Reducing Entropy approach:
1. Load mindset (e.g., "worse-is-better.md")
2. Ask: What's the smallest codebase that solves this?
- Could we have 1 validation function instead of 5 schemas?
- Do all 5 forms need validation or just 2?
- Can we delete 3 forms and merge functionality?
3. Count before/after:
- Before: 5 forms + 0 validation = 500 lines
- Option A: 5 forms + 6 validation files = 800 lines (reject)
- Option B: 2 forms + 1 validation function = 350 lines (accept)
4. Delete: Remove 3 forms, add 1 function
- Net result: -150 lines
```
## Related Files
- `references/` - Philosophical mindsets to load before starting
- `adding-reference-mindsets.md` - How to add new mindsets
## Success Metrics
You've succeeded when:
- Total lines of code decreased
- Number of files decreased
- Number of functions/classes decreased
- Features work the same (or better) with less code
- You deleted more than you added
---
**Bias toward deletion. Measure the end state.**
## Attribution
- Original skill by @joshuadavidthomas from [joshuadavidthomas/agent-skills](https://github.com/joshuadavidthomas/agent-skills) (MIT)
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 470k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |