Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent: Claude Code, Codex, Cursor, Antigravity, Grok-Build, Hermes, OpenClaw, Pi, etc.
Quickstart · Index · The Map · The Problem · The Fixes · Credits
- Install for every agent you use:
npx skills@latest add LilMGenius/paperthin --global --agent '*' - Run it elevated so the skills are symlinked (they auto-update), not copied.
- Use them — model-invoked, so your agent reaches for them on its own; or call one by name, like
/re0.
Not sure? Paste that command into whatever agent you're using and just say "set this up for me" — it'll do the rest.
| Skill | Scope | What it does |
|---|---|---|
| ♻️ re0 | one artifact | Rewrite a drifted artifact into a clean v0 — not another patch |
| 🚿 shower | one artifact | Cold-read it with fresh, zero-context eyes — does it stand on its own? (read-only) |
| 🔬 factchk | one claim | Verify a reality-grounded claim against sources, both directions — could the absurd be real, the obvious false? (read-only → fix) |
| 🧪 mandela | one eval | Audit a validation for leakage — does outside ground-truth actually enter? Walks 8 patterns (read-only) |
| 🔎 ssotchk | many artifacts | Find where one fact is scattered or duplicated; name the canonical source (read-only) |
| 🧲 ssotize | many artifacts | Consolidate it into one home and point the rest at it |
| 🥄 sip | your output | After any change, auto-runs shower + ssotchk + re0 on it |
| Skill | Scope | What it does |
|---|---|---|
| 🧾 re0-git | one commit | Rewrite a finished commit's message into a clean v0 so git log alone hands off |
| ⚔️ redteam | one plan | Try to kill it before reality does — the one root flaw + the cheapest experiment that falsifies it |
How many artifacts, and across how much time?
Two axes — cardinality × time — carve four regions.
Most agent skills are slop.
Point an agent at a goal and it adds — more files, more options, more "helpful" boilerplate. Adding looks like progress, and nothing ever makes it go back and delete.
Warning
Repeat that across a project and you get the familiar AI-generated toolkit: near-duplicate skills, dead settings, a README that says the same thing three times. Plausible, busy, and quietly unmaintainable.
These skills bet the other way — every one of them removes:
re0rewrites a draft into a clean v0 instead of patching it,ssotchk/ssotizecollapse the same fact scattered across files,showercuts whatever a stranger can't follow,sipruns all of it on your own output, automatically.
Tip
The hard part isn't adding features — it's restraint. A pass that finds nothing to improve changes nothing. That restraint is the product.
Each is a well-worn principle, made automatic.
Edit a doc one piece at a time across a session and it bloats: stale deltas, duplicated noise, changelog scars. Patching on top just preserves the rot.
The fix → re0: rewrite the artifact as a clean v0, as if it were the first version.
Prior art: the Boy Scout Rule — "leave it cleaner than you found it" (Robert C. Martin, Clean Code, 2008).
re0goes further: rewrite, don't just tidy.
[PROOF]
- Setup — we asked
re0to refresh these docs once more, but they were already at v0. - Result — it found nothing to improve and left every line of prose untouched.
- So — a tool that does nothing when nothing is wrong never bloats your repo: these skills remove noise, they never add it.
After a long session you're the one person who can't read your own work straight: you know too much, so your brain quietly fills every gap and the holes turn invisible.
The fix → shower: hand a stranger who never saw your session only the artifact, and ask "does this actually make sense?"
Prior art: egoless programming — you can't review your own work objectively; someone else must (Gerald Weinberg, 1971). Here, that someone is a context-free sub-session.
[PROOF]
- Setup — we handed
showerits own spec, to a sub-session with zero context, holding only the file. - Result — in minutes it found three bugs the author had missed:
- a step that hinted the answer it should hide,
- a path that leaked spoiler files,
- a scope too vague to act on.
- So — a skill that catches its own bugs can catch yours.
A timeout value, a decision, a status — copied into a README, a doc, a ticket, and a Slack thread. The copies drift, and now no one knows which is true.
The fix → ssotchk + ssotize: find the scatter, name the canonical source, then consolidate and point the rest at it.
Prior art: DRY — one fact, one authoritative home (Hunt & Thomas, The Pragmatic Programmer, 1999).
A guideline buried in docs won't trigger in a brand-new session — exactly when author bias is highest.
The fix → sip: the moment you finish something, it runs shower, ssotchk, and re0 on your output, automatically.
Prior art: dogfooding — eat your own dog food (Microsoft, 1988). Taste your own cooking before you serve it.
Your session is stuck where it ran — this agent, this account, this machine. A teammate or another agent can't load the context your work happened in.
The fix → re0-git: clean a finished commit's message so git log — the one thing every environment shares — carries the handoff, and anyone picks up from the log alone.
[PROOF]
- Setup —
re0-git's very first target was its own release commit. - Result — dogfooding it surfaced two faults, both fixed:
- a message padded with trivia,
- a spec that preached "no redundancy" while repeating itself.
- So — its first cleanup was after itself.
Note
The five fixes above keep an artifact clean. The next three keep it true — the same distrust of the author, turned on the reasoning instead of the prose.
"Plausible," "absurd," "novel" — the least reliable line in any artifact. Human priors fail both ways: they exclude the real (desert frogs exist) and normalize the impossible (weightless crates).
The fix → factchk: verify any reality-grounded claim against external sources, in both directions, before it ships — and flag, don't guess, when you can't reach one.
Prior art: WEIRD bias (Henrich, Heine & Norenzayan, 2010) and the naive-physics / impetus error (McCloskey, Caramazza & Green, 1980) — intuition misjudges reality in both directions.
[PROOF]
- Setup — we ran
factchkon its own shipped citations, in both directions. - Result — all held, and it still caught two attribution slips to fix: the famous "what's measured becomes the target" wording is Strathern (1997), not Goodhart; and "McCloskey 1980" is the co-authored Science paper, not the 1983 Scientific American piece.
- So — a fact-checker that audits its own footnotes will audit yours.
A model, a scorer, and a designer can all agree a result is real while no outside ground-truth ever entered the loop — a whole room confidently remembering something that never independently happened.
The fix → mandela: audit any eval, metric, or experiment against an 8-pattern leakage taxonomy — does external ground-truth enter independently, or is the verifier the designer?
Prior art: Goodhart's law, data leakage (Kaufman et al., 2012), and circular analysis — "double dipping" (Kriegeskorte et al., 2009).
You built it, so you defend it. The questions that would break it are exactly the ones you won't ask.
The fix → redteam: try to kill the plan before reality does — return the single load-bearing flaw and the cheapest experiment that would falsify it (the "first nail"), not a checklist. User-invoked: you point it at a plan deliberately.
Prior art: egoless programming (Weinberg, 1971 — the same root
showercites), red-teaming, and fail-fast.
- Built on mattpocock/skills (MIT) — its architecture and philosophy.
- Not a fork — these are LilMGenius's own, non-overlapping workflows.
- Vendored verbatim — a few shared building blocks, kept as-is with per-source attribution in NOTICE.
- Authoring guide — conventions and philosophy live in CLAUDE.md.