reducing-entropy

Guides refactoring decisions that minimize total codebase size through deletion and simplification.

Updated Jun 2, 2026
One-click install
npx skills add https://github.com/lfuuu/claude-rules --skill reducing-entropy-lfuuu
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reducing-entropy
Source: https://github.com/lfuuu/claude-rules/tree/main/global-skills/reducing-entropy
Command: npx skills add https://github.com/lfuuu/claude-rules --skill reducing-entropy-lfuuu

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Codebases naturally grow over time, and more code means more bugs, more maintenance, and more cognitive load. This Skill counters that tendency by evaluating every change based on whether it reduces the total amount of code, not how little effort it takes. ## Core Features & Use Cases - Deletion-biased evaluation: Judges changes by final codebase size, rejecting additions even when they seem better organized or more flexible. - Three-question framework: Asks what the minimal codebase looks like, whether the change reduces total code, and what can be deleted. - Reference mindsets: Loads philosophical frameworks from references/ (simplicity vs ease, data over abstractions, PAGNI exceptions) before making decisions. - Use Case: When asked to add validation to 5 forms, instead of creating 6 new files, the Skill pushes toward merging forms and adding a single validation function for a net reduction of lines. ## Quick Start Ask the agent to apply the reducing-entropy skill to review this module and remove as much code as possible while keeping functionality intact.

Frequently Asked Questions about reducing-entropy

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I reduce the size of an existing codebase?

Evaluate each change by its net effect on total lines, files, and functions rather than effort spent. Ask what the minimal codebase solving the problem looks like, reject changes that increase total code, and treat every modification as an opportunity to delete obsolete code.

What is the reducing-entropy skill and when should I use it?

It is a manual-only refactoring skill that biases toward deletion and measures success by final codebase size. Use it when refactoring, evaluating feature requests, or paying down technical debt, and only when explicitly requested.

When should I not apply aggressive code deletion?

Avoid it when the codebase is already minimal for its requirements, when working within a framework with rigid conventions, or when regulatory requirements dictate a specific structure. Fighting the framework or compliance rules creates more problems than it solves.

What is the difference between YAGNI and PAGNI in code simplification?

YAGNI says do not build features you might never need, while PAGNI identifies exceptions where retrofitting is dramatically more expensive, such as timestamps, audit logs, API versioning, and pagination. PAGNI applies only when later addition is roughly ten times costlier.

Why does the skill reject arguments like better separation of concerns?

Because more files and functions mean more code, and separation is not free. The skill treats flexibility, type safety, and organization as red flags when they increase total code volume, since fourteen entities are never easier to understand than two.