Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/lilmgenius/paperthin

Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent.
https://github.com/lilmgenius/paperthin

Last synced: 18 days ago
JSON representation

Plain-Markdown skills that turn old engineering wisdom into reflexes your agent reaches for on its own — on any agent.

Awesome Lists containing this project

README 

          



# Paperthin: Low-level agentic design patterns



Paperthin — Trust the artifact, not the author.



**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](#quickstart-15-seconds) · [The Map](#the-map) · [The Index](#the-index) · [The Problem](#the-problem) · [The Fixes](#the-fixes) · [Credits](#credits)






---



## Quickstart (15 seconds)



1. **Install** for every agent you use:

   ```bash

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

   ```

2. **Run it elevated** so the skills are symlinked (they auto-update), not copied.

3. **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.



## The Map



**How many artifacts, and across how much time?**





The Paperthin map by LilMGenius/paperthin, a two-by-two matrix. Horizontal axis cardinality (one, then many); vertical axis time (now, then across iterations); four regions. Top-left, depth: one artifact, now; is this one thing clean and true? Top-right, breadth: many artifacts, now; is one truth consistent everywhere? Bottom-left, coil: one project, across iterations; did each pass teach the next? Bottom-right, mesh: many minds, across rounds; does the crowd converge on truth?




## The Index



### `depth/`



| Skill | What it does | Scope | Invoker |

|---|---|---|---|

| ♻️ **[re0](./skills/depth/re0/SKILL.md)** | Rewrite a drifted artifact into a clean v0 — not another patch | one artifact | model |

| 🚿 **[shower](./skills/depth/shower/SKILL.md)** | Cold-read it with fresh, zero-context eyes — does it stand on its own? *(read-only)* | one artifact | model |

| 🔬 **[factchk](./skills/depth/factchk/SKILL.md)** | Verify a claim against sources, both directions — could the absurd be real, the obvious false? *(read-only → fix)* | one claim | model |

| 🧪 **[mandela](./skills/depth/mandela/SKILL.md)** | Audit a validation for leakage — does outside ground-truth actually enter? *(read-only)* | one eval | model |

| 🛣️ **[autobahn](./skills/depth/autobahn/SKILL.md)** | Carve unsafe scope out up front, run the safe rest at full strength, ship a descope ledger | one task | model |

| 🥄 **[sip](./skills/depth/sip/SKILL.md)** | After any change, tastes it with the repo's own clean-and-true checks | your output | model |

| 😈 **[hate](./skills/depth/hate/SKILL.md)** | Refuse to be nice to it — the one objection that could kill it + the cheapest test | one plan | user |

| ✂️ **[dedash](./skills/depth/dedash/SKILL.md)** | Remove em-dashes and their look-alikes, choosing the punctuation each spot needs | your prose | user |

| 🧾 **[re0-git](./skills/depth/re0-git/SKILL.md)** | Rewrite a finished commit's message into a clean v0 so `git log` alone hands off | one commit | user |



### `breadth/`



| Skill | What it does | Scope | Invoker |

|---|---|---|---|

| 🔎 **[ssotchk](./skills/breadth/ssotchk/SKILL.md)** | Find where one fact is scattered or duplicated; name the canonical source *(read-only)* | one fact, many places | model |

| 🧲 **[ssotize](./skills/breadth/ssotize/SKILL.md)** | Consolidate it into one home and point the rest at it | one fact, many places | model |

| 🧰 **[ppt-upgrade](./skills/breadth/ppt-upgrade/SKILL.md)** | Reconcile old installed Paperthin skill names after releases | installed skill names | user |



### `coil/`



| Skill | What it does | Scope | Invoker |

|---|---|---|---|

| 🧭 **[retro](./skills/coil/retro/SKILL.md)** | Extract the lessons and anti-patterns from a finished or failed cycle | one finished cycle | model |

| 🧱 **[re0-work](./skills/coil/re0-work/SKILL.md)** | Restart from v0, keeping only the lessons that earned reuse | one restart | model |

| 🌀 **[flywheel](./skills/coil/flywheel/SKILL.md)** | Run the build → QA → retro → re0-work loop so learning compounds, not code | the whole loop | model |

| 🎯 **[nba](./skills/coil/nba/SKILL.md)** | Read the live cycle state and return the single next best action, not a menu *(read-only)* | the live cycle | model |



### `mesh/`



*In development — converge independent views into consensus.*



*More on invocation: [docs/invocation.md](./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,

- `ssotchk` / `ssotize` collapse the same fact scattered across files,

- `shower` cuts whatever a stranger can't follow,

- `retro` / `re0-work` preserve the lesson and let the wrong build die,

- `autobahn` carves unsafe scope out up front, so the safe remainder runs at full speed,

- `dedash` removes even the em-dash tell and its look-alikes, one judged occurrence at a time,

- `sip` runs 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.**



## 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](https://www.informit.com/articles/article.aspx?p=1235624&seqNum=6), 2008). `re0` goes further: rewrite, don't just tidy.*



[PROOF]



- **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 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](https://en.wikipedia.org/wiki/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 `shower` its 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.



### #3 — 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 → `ssotchk` + `ssotize`:** find the scatter, name the canonical source, then consolidate and point the rest at it.



> *Prior art: [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) — one fact, one authoritative home (Hunt & Thomas, The Pragmatic Programmer, 1999).*



### #4 — "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`, `ssotchk`, `re0`) and, when there's a claim or an eval, the true ones (`factchk`, `mandela`) on your output, automatically.



> *Prior art: [dogfooding](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) — eat your own dog food (Microsoft, 1988). Taste your own cooking before you serve it.*



[PROOF]



- **Setup** — right after a large refactor that made every skill self-contained, `sip` auto-fired on the result.

- **Result** — its fresh-eyes pass caught two things the author could no longer see: a maintenance rule still pointing at skill-to-skill links that the same refactor had just deleted, and a file-editing safety rule present in two skills but missing from a third that also edits files.

- **So** — the check bites where bias is highest: not on a fresh artifact, but on the drift a big change leaves behind — exactly what the author's own eyes skate over.



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



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



### #6 — 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](https://www.cambridge.org/core/journals/behavioral-and-brain-sciences/article/abs/weirdest-people-in-the-world/BF84F7517D56AFF7B7EB58411A554C17) (Henrich, Heine & Norenzayan, 2010) and the [naive-physics / impetus error](https://www.science.org/doi/10.1126/science.210.4474.1139) (McCloskey, Caramazza & Green, 1980) — intuition misjudges reality in both directions.*



[PROOF]



- **Setup** — we ran `factchk` on 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.



### #7 — 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](https://en.wikipedia.org/wiki/Goodhart%27s_law), [data leakage](https://dl.acm.org/doi/10.1145/2382577.2382579) (Kaufman et al., 2012), and [circular analysis](https://www.nature.com/articles/nn.2303) — "double dipping" (Kriegeskorte et al., 2009).*



[PROOF]



- **Setup** — the audit was distilled from one research design that kept dying to a single failure mode: a scorer, a model, and a designer agreeing on a result no outside truth ever produced.

- **Result** — leakage surfaced in eight distinct shapes in that one project — a scorer grading buckets it had drawn, two components "verifying" each other in a shared space, a private recipe that made the verifier the designer — and that catalog became the skill's 8-pattern taxonomy.

- **So** — the checklist isn't theoretical: every pattern in it already drew blood once.



### #8 — 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](https://en.wikipedia.org/wiki/Egoless_programming) (Weinberg, 1971 — the same root `shower` cites), hostile review, and fail-fast.*



[PROOF]



- **Setup** — every research pass closed with an adversarial critic, and its verdict was always one root cause plus the cheapest test that would settle it, never a checklist.

- **Result** — it killed a recombination engine with "one more box drawn, not a sharper tip", and a human-holdout protocol on the numbers alone: n≈24 where 36 was needed, a family-wise error rate near 34%, and a design that cited a principle while implementing its opposite.

- **So** — the objection that mattered was always singular and cheap to test — exactly the `{root, first nail}` that `hate` is locked to return.



### #9 — A running build can still be the wrong product

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. Then between passes the next move blurs into a dozen live threads at once, and too many options is its own paralysis.



**The fix → `retro` + `re0-work` + `flywheel` + `nba`:** extract the lesson, anti-pattern, and next gate; restart from a clean v0 when the foundation is wrong; run the build → QA → retro → re0-work loop; and when the thread is lost, read the state and return the single next best action. Keep only what earned reuse.



[PROOF]



- **Setup** — a game-engine demo reached a full-stack, runnable state: API routes, a canvas runtime, a leaderboard, arcade pages, remix and telemetry panels, tests, screenshots.

- **Result** — and it was still the wrong product — the generated games were mock, one-screen, with no durable replay layer — while every pass ended in "what now?" against a pile of unmet gates and parked threads.

- **So** — running and shipping-shaped is not done; the cycle needs a skill to name the missing gate and one to return the single next move.



### #10 — 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](https://www.anthropic.com/news/fable-mythos-access) over one jailbryoken safeguard (Anthropic, 2026), and OpenAI shipped [GPT-5.6](https://openai.com/index/previewing-gpt-5-6-sol/) safety-stack-first to trusted partners (OpenAI, 2026) — at the frontier, the fast lane stays open only as far as entry discipline holds.*



[PROOF]



- **Setup** — the method was lifted from a live rewrite of a confidential strategy doc that was risk-adjacent on four axes at once: stealth tooling, trademarked names, privacy-adjacent profiling, scraping gray zones.

- **Result** — a main loop plus ten subagents ran the frontier model end to end with zero flags, zero refusals, zero fallbacks — and every descoped item's safe alternative turned out to be the better product anyway.

- **So** — the main loop carved, clean subagents ran the safe scope, and the carve is why they could floor it.



## Credits



- **Built on** [mattpocock/skills](https://github.com/mattpocock/skills) (MIT) — its architecture and philosophy.

- **Not a fork** — these are [LilMGenius](https://github.com/LilMGenius)'s own, non-overlapping workflows.

- **Vendored verbatim** — a few shared building blocks, kept as-is with per-source attribution in [NOTICE](./NOTICE).

- **Authoring guide** — conventions and philosophy live in [CLAUDE.md](./CLAUDE.md).