Requirements
- Target platform
- OpenClaw
- Install method
- Manual import
- Extraction
- Extract archive
- Prerequisites
- OpenClaw
- Primary doc
- SKILL.md
Tencent SkillHub Β· Developer Tools
Reducing Entropy
Minimize total codebase size through ruthless simplification. Measure success by final code amount, not effort. Bias toward deletion.
skill openclawclawhub Free
Minimize total codebase size through ruthless simplification. Measure success by final code amount, not effort. Bias toward deletion.
β¬ 0 downloads β
0 stars Unverified but indexed
Install for OpenClaw
Quick setup
- Download the package from Yavira.
- Extract the archive and review SKILL.md first.
- Import or place the package into your OpenClaw setup.
Package facts
- Download mode
- Yavira redirect
- Package format
- ZIP package
- Source platform
- Tencent SkillHub
- What's included
- README.md, SKILL.md, references/data-over-abstractions.md, references/design-is-taking-apart.md, references/expensive-to-add-later.md, references/simplicity-vs-easy.md
Validation
- Use the Yavira download entry.
- Review SKILL.md after the package is downloaded.
- Confirm the extracted package contains the expected setup assets.
Install with your agent
Agent handoff
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
New install
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Then review README.md for any prerequisites, environment setup, or post-install checks. Tell me what you changed and call out any manual steps you could not complete.
Upgrade existing
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Then review README.md for any prerequisites, environment setup, or post-install checks. Summarize what changed and any follow-up checks I should run.
Trust & source
Release facts
- Source
- Tencent SkillHub
- Verification
- Indexed source record
- Version
- 0.1.0
Provenance
- Publisher
- wpank
- Source page
- View original listing
- Canonical URL
- Open canonical page
Documentation
Reducing Entropy
More code begets more code. Entropy accumulates. This skill biases toward the smallest possible codebase.
WHAT This Skill Does
Provides a mindset and checklist for: Evaluating whether changes reduce or increase total code Finding opportunities to delete code Resisting premature abstraction Choosing the simplest solution that solves the problem Core question: "What does the codebase look like after?"
WHEN To Use
Activate this skill when: Refactoring code and considering options Adding a new feature and choosing implementation approach Reviewing PRs to challenge unnecessary complexity Paying down tech debt and prioritizing what to simplify User explicitly asks for code reduction or simplification
The Goal
The goal is less total code in the final codebase β not less code to write right now. ScenarioVerdictWriting 50 lines that delete 200 linesNet win βKeeping 14 functions to avoid writing 2Net loss β"Better organized" but more codeMore entropy β"More flexible" but more codeMore entropy β"Cleaner separation" but more codeMore entropy β Measure the end state, not the effort.
Before You Begin
Load a mindset from references/: List files in references/ Read frontmatter descriptions Pick at least one that applies State which you loaded and its core principle Available mindsets: simplicity-vs-easy.md β Simple is objective; easy is subjective. Choose simple. design-is-taking-apart.md β Good design separates concerns, removes dependencies. data-over-abstractions.md β 100 functions on one structure beats 10 on 10. expensive-to-add-later.md β When YAGNI doesn't apply (PAGNI exceptions).
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, challenge it. Before: 847 lines across 12 files After: 623 lines across 8 files Verdict: β Net reduction of 224 lines
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
PhraseWhat It HidesChallenge"Keep what exists"Status quo bias"Total code is the metric, not churn""This adds flexibility"Speculative generality"Flexibility for what? Is it needed now?""Better separation of concerns"More files = more code"Separation isn't free. Worth how many lines?""Type safety"Sometimes bloats code"Worth how many lines? Could runtime checks work?""Easier to understand"More things β easier"14 things are not easier than 2 things""This is the pattern"Pattern worship"Does the pattern fit, or are we forcing it?""We might need this later"YAGNI violation"Delete it. Git remembers."
Deletion Checklist
Before completing any refactor, ask: Did I count lines before and after? Did I delete everything this change makes obsolete? Did I remove any now-unnecessary abstractions? Did I consolidate files that are too small to stand alone? Did I delete tests for deleted code? Did I update imports to remove dead dependencies?
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 The "simpler" version would be genuinely unmaintainable (rare)
NEVER Do
NEVER keep code "in case we need it" β delete it; git has history NEVER add abstractions for fewer than 3 use cases β wait for the pattern to emerge NEVER create new files for single functions β colocate with usage NEVER preserve code just because someone wrote it β evaluate on merit NEVER accept "more organized" as justification for more code β organization should reduce, not increase NEVER skip the line count β measure before and after; feelings lie NEVER add "flexibility" without immediate need β YAGNI applies NEVER refactor without deleting something β if nothing becomes obsolete, question the value
Quick Wins
PatternActionWrapper that just forwards callsInline the wrapped codeConfig file with 2 settingsMove to environment variablesUtils file with 1 functionMove function to where it's usedInterface with 1 implementationDelete the interfaceAbstract class with 1 subclassMerge into concrete classModule that re-exports everythingDelete; import from sourceComments explaining obvious codeDelete comments; code is clear
The Grug Perspective
"complexity very very bad. say again: complexity very bad. you think you not, but you are." Grug brain developer knows: Complexity demon hides in abstraction More code = more bugs = more complexity Best code is no code Second best code is simple code If you can't understand it in your head, it's too complex
References
Philosophical foundations for simplicity thinking: ReferenceCore Principlesimplicity-vs-easy.mdSimple (objective) vs easy (subjective) β choose simpledesign-is-taking-apart.mdGood design separates; composition beats constructiondata-over-abstractions.mdGeneric data + many functions beats many custom typesexpensive-to-add-later.mdPAGNI exceptions β what you probably are gonna need External resources: Simple Made Easy β Rich Hickey The Grug Brained Developer Out of the Tar Pit β Moseley & Marks
Category context
Code helpers, APIs, CLIs, browser automation, testing, and developer operations.
Source: Tencent SkillHub
Largest current source with strong distribution and engagement signals.
Package contents
Included in package
6 Docs
- SKILL.md
- README.md
- references/data-over-abstractions.md
- references/design-is-taking-apart.md
- references/expensive-to-add-later.md
- references/simplicity-vs-easy.md