lilmgenius/paperthin

---

Quickstart (15 seconds)

1. Install for every agent you use:

   npx skills@latest add LilMGenius/paperthin --global --agent '*'
   

2. Run it from an elevated/admin shell if your OS asks so the skills are symlinked (they auto-update), not copied.
3. Stay current — run /re0-upgrade whenever you want to update; it also wires a quiet session-start notice for when new skills ship.
4. Use them — call any skill by name, like /re0; model-invoked ones also fire on their own.

Not sure? Paste that command into whatever agent you’re using and just say set this up for me, it’ll do the rest.

The Map

How many artifacts, and across how much time?

The Index

depth/

breadth/

coil/

mesh/

More on invocation: docs/invocation.md

The Problem

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:

• re0 rewrites a draft into a clean v0 instead of patching it,
• readchk restates the request and asks only when a real fork survives,
• aim reads a handed-over data drop and proposes the intent to confirm, instead of asking for it,
• modelchk sizes the cheapest sufficient capability tier and reasoning effort before the work starts,
• macrothink fans out fresh reads and reports divergence before convergence reads as proof,
• feynman presses a just-made decision until you can explain it to a skeptic, or names the gap you can’t,
• prism splits one artifact across independent lenses and returns where they clash, never their average,
• autobahn carves unsafe scope out up front, so the safe remainder runs at full speed,
• detool strips incidental stack nouns from portable content, leaving the mechanism they meant,
• dedash removes even the em-dash tell and its look-alikes, one judged occurrence at a time,
• debloat compresses a bloated artifact to its load-bearing density, cutting words but never a rule,
• shower cuts whatever a stranger can’t follow,
• ssotize audits scattered facts, asks approval, then folds them into one home,
• reorder realigns a drifted listing under one principle, moving items and rewording nothing,
• sip runs all of it on your own output, automatically,
• re0-memo / re0-work / re0-loop preserve the lesson, let the wrong build die, and keep the cycle running,
• catchup / nba reload the human’s map from live state, then return the one next move.

[!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.

The Fixes

Each is a well-worn principle, made automatic.

#1 — Artifacts rot

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). re0 goes further: rewrite, don’t just tidy.

#2 — You can build the wrong request perfectly

A long or bundled instruction has enough surface area for a subtle misread: the agent starts work, stays coherent, and only later proves it optimized the wrong target.

The fix → readchk: restate the instruction internally, cross-check it against available context, proceed silently when the read is resolved, and ask only when one real fork survives.

#3 — Sizing the run becomes guesswork

Some work is run with too much horsepower because “stronger” feels safer; some is run too cheaply until the failure costs more than the saved tokens. The same guessing hits the reasoning-effort dial: max it on everything and burn tokens, or skim a task that needed real deliberation. All of it is guessing wearing operational clothing.

The fix → modelchk: from one risk read, recommend two coordinates — the cheapest sufficient capability tier (fast, standard, frontier) and the reasoning effort within it (glance to exhaustive), each on a neutral scale. It advises; it never routes, pins, or names a concrete model or level.

#4 — You can’t kill your own plan

You built it, so you defend it. The questions that would break it are exactly the ones you won’t ask.

The fix → hate: refuse to be nice to the plan — return the one load-bearing objection that could kill it and the cheapest experiment that would prove it matters. User-invoked: you point it at a plan deliberately.

Prior art: egoless programming (Weinberg, 1971 — the same root shower cites), hostile review, and fail-fast.

#5 — One framing becomes the whole world

Examples, names, and first plausible answers can trap a session before the plan even looks risky. A single agent may keep improving the inherited frame instead of noticing a different read.

The fix → macrothink: user-invoke a read-only fan-out: strip the session’s bait, ask 2 to 5 fresh reads for the underlying problem, and report divergence first. Same-model convergence is reassurance only, never proof.

#6 — Risk-adjacent work comes back hedged

Point an agent at a task that brushes guardrails — scraping, licensing, privacy, security — and you get the worst of both worlds: the risky sliver triggers refusals and retries, while the safe 90% comes back hedged, diluted, or quietly missing.

The fix → autobahn: carve guardrail-adjacent items out of scope before execution, each with a safe alternative and an archive entry; run the remaining scope at full strength in a fresh subagent that only ever sees the carved prompt, not the risky input; ship a descope ledger so every exclusion is a visible decision, not a silent gap. It removes the ask rather than slipping it past. The autobahn has no speed limit because entry discipline is strict.

Prior art, from this very summer: the US suspended Fable 5 and Mythos 5 over one jailbroken safeguard (Anthropic, 2026), and OpenAI shipped GPT-5.6 safety-stack-first to trusted partners (OpenAI, 2026) — at the frontier, the fast lane stays open only as far as entry discipline holds.

#7 — Portable docs smuggle their toolchain

A durable artifact says it should work across agents, hosts, and time, but its prose quietly depends on one vendor, model, CLI, path, quota, or UI. Portability dies by nouns.

The fix → detool: classify the text by role first, then replace incidental stack coupling in portable content with the mechanism it meant, while leaving provenance, runbooks, and tool-subject claims concrete.

#8 — You go blind to your own work

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.

#9 — The same fact ends up everywhere

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 → ssotize: find the scatter, name the canonical source, ask approval for the mutation plan, then consolidate and point the rest at it.

Prior art: DRY — one fact, one authoritative home (Hunt & Thomas, The Pragmatic Programmer, 1999).

#10 — A list’s order stops meaning anything

Items get appended where they were typed, not where they belong. Kin drift apart, the sequence follows no axis a reader can feel, and an order that was information now says nothing.

The fix → reorder: realign the listing under one nameable principle, moving items only — nothing reworded, added, or removed.

#11 — Your gut isn’t a source

“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.

#12 — The eval confirms itself

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).

#13 — “Remember to verify” never fires

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 the clean checks (shower, ssotize, re0) and, when there’s a claim or an eval, the true ones (factchk, mandela) on your output, automatically.

Prior art: dogfooding — eat your own dog food (Microsoft, 1988). Taste your own cooking before you serve it.

#14 — Your session doesn’t travel; the git log does

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.

#15 — Long cycles lose the build, and the builder

Long agentic cycles produce many working parts — panels, routes, tests, screenshots — that prove activity more than value, and the sunk cost tempts you to carry the architecture forward. The same cycles coin vocabulary, rename files, and make calls faster than the human owner can follow, so even a correct next action arrives unreadable: phrased in words invented while they were away.

The fix → re0-memo + re0-work + re0-loop + catchup + nba: extract the lesson, anti-pattern, and next gate; restart from a clean v0 when the foundation is wrong; run the build → QA → re0-memo → re0-work loop. When the owner’s mental model has gone stale, catchup rebuilds it first from live state, not conversation memory: what needs them, what changed, what new words mean. Only then does nba read the live cycle and return the single next best action. Keep only what earned reuse.

Credits

• 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.