reducing-entropy
npx machina-cli add skill softaworks/agent-toolkit/reducing-entropy --openclawReducing 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/
- List the files in the reference directory
- Read frontmatter descriptions to pick which applies
- Load at least one
- 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.
Source
git clone https://github.com/softaworks/agent-toolkit/blob/main/skills/reducing-entropy/SKILL.mdView on GitHub Overview
Reducing Entropy is a manual-only skill that minimizes the total codebase by biasing toward deletion. It focuses on the end state—what the codebase looks like after changes—rather than effort spent. It activates only when explicitly requested by the user.
How This Skill Works
Before you begin, load at least one mindset from references and state which you loaded. Then apply the three guiding questions to determine the smallest possible end state and whether a proposed change reduces total code. If the end state would have more code, the change is rejected.
When to Use It
- Auditing a large codebase to remove dead or obsolete code.
- Planning a feature removal or consolidation to reduce footprint.
- Evaluating proposed changes that might increase total lines of code.
- Preparing a lean deployment where code size matters.
- Deciding whether to keep or delete a module during refactoring.
Quick Start
- Step 1: Load at least one mindset from references/ and state its core principle.
- Step 2: Answer the three questions to identify the minimal end state and whether the change reduces total code.
- Step 3: Delete nonessential code to reach the smallest end state and verify the final line count.
Best Practices
- Load at least one mindset from references/ and state its core principle before acting.
- Always compare total lines of code before and after the change.
- Bias toward deleting obsolete, redundant, or unnecessary code.
- Reject changes that increase total entropy or code quantity.
- Document exactly what was deleted and why to justify the end-state.
Example Use Cases
- Deleting a deprecated API wrapper and its related 200 lines to streamline the codebase.
- Consolidating 14 tiny helper functions into a single core utility, reducing code surface area.
- Removing an unused plugin entirely, along with stale configuration, cutting both code and config noise.
- Eliminating duplicate or redundant validation logic that was superseded by a centralized check.
- Stripping test scaffolding that is no longer needed after a feature removal.
