Index of every page on this site: llms.txt
All skills
softaworks avatar

/reducing-entropy

@3027f20
by softaworkssoftaworks/agent-toolkit2.7k stars
254
Run it yourself

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.

Use this Skill: https://skilld.dev/gh/softaworks/agent-toolkit/reducing-entropy

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈48 tokens for metadata: the name and description. ≈584 when used: this file. ≈4.2k more on demand in 6 files.

Description uses 2.4% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈194 characters, or 2.4%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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.

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts2mo5 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    The skill provides a framework for reducing code complexity through deletion and simplification. It is conceptually safe but carries a low risk of indirect prompt injection, as it requires the agent to analyze and modify external codebases that could contain malicious instructions designed to trick the agent into removing security controls.

  • Socket2mo

    No alerts

  • Snyk2mo

    Risk: LOW · No issues

  • Runlayer8mo

    7 files scanned · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 3027f20. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last month.

Dormantupdated 10 months ago
  • Refactoring
  • entropy
  • code-deletion
  • codebase-size
  • minimalism
  • technical-debt
  • architecture

README badge

README badge for softaworks/agent-toolkit/reducing-entropy

Reduces total codebase size by favoring deletion over addition, measuring success by final code amount rather than effort or refactoring elegance. Requires explicit user activation and loading a reference mindset before proceeding; applies to any project where minimizing lines of code is the primary goal, not organizational improvements.

Generated from the current SKILL.md.

When should I activate this skill?
Only when explicitly requested by the user. This is a manual-only skill for focused reduction efforts, not a default mode.
What does 'success' mean for this skill?
Success is measured by final codebase size, not effort or refactoring cleanliness. Writing 50 lines to delete 200 lines is a win.
Does this skill apply to all codebases?
No. Skip it if the codebase is already minimal, if you're constrained by framework conventions or regulatory requirements, or if reduction isn't the stated goal.
How do I use the reference mindsets?
Load at least one mindset from the references/ directory before proceeding. Read the frontmatter descriptions to find which applies, then state which you loaded.

Generated from the current SKILL.md. These answers refresh after source changes.