paperthin

Paperthin: Low-level agentic design patterns

Turning old engineering wisdom into reflexes your agent reaches for on its own.

On any agent | Claude Code, Codex, OpenCode, Antigravity, Copilot, Cursor, Grok-Build, Pi, Hermes, OpenClaw, etc.

Quickstart · The Map · The Index · The Problem · The Fixes · Credits

Read in: English · 中文 · हिन्दी · Español · العربية · Português · Русский · 日本語 · Français · Deutsch · 한국어

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.

• Setup — we asked re0 to 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.

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

• Setup — its first casebook mixed flexible ordering, a concrete file creation, a resolved "that", and a bundled ambiguous update.
• Result — it surfaced only the real forks and stayed silent on the concrete and context-resolved cases.
• So — the check catches expensive misreads without turning clear instructions into confirmation theater.

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