Skip to main content
skill CX Codex

backprop · lilmgenius — Claude Code skill: what it does, how to install

backprop — a skill for Claude Code feeds lessons from errors and corrections back into source files. Runs after failed cycles, repeated user prompts, or during rule cleanup passes.

MIT 120 installs ★ 1,470 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add LilMGenius/paperthin --skill backprop -a claude-code
Open on GitHub

What backprop does

The tool carries corrections from finished outputs back into the documentation, instructions, or code that produced them. It starts by pinning the scope to the relevant files. Once confirmed, it invokes a pipeline of companion skills from the paperthin suite: re0-memo categorizes the issue, elon challenges related requirements, ssotize assigns the canonical owner, while re0, debloat, and re0-order clean up the resulting text.

Every pass runs strictly in sequence and executes only when its specific condition is met. The process respects user approval gates during rule questioning and deduplication. Edits stay strictly within the working tree because the workflow never stages, commits, or pushes git changes.

Execution halts immediately if re0-memo is missing since the pipeline cannot derive lessons without it. Punctuation cleaners like dedash and dedot are never run automatically; the skill only names affected files for manual handoff.

What it helps with

  • Propagate review corrections back into project documentation
  • Audit requirement assumptions that allowed an error to pass
  • Consolidate scattered rules into a single source of truth
  • Strip redundant phrasing from source files after manual updates

Example prompts for the agent

  • Run backprop on the docs affected by the latest correction
  • Feed the lessons from the failed test run back into our agent rules
  • Apply backprop to reconcile duplicate guidelines in the repository

How to install backprop

1Skills CLI (Vercel)

npx skills add LilMGenius/paperthin --skill backprop -a claude-code

2Manually: put the files in place

~/.claude/skills/backprop/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/backprop/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about backprop

How to install backprop in Claude Code?

Run npx skills add LilMGenius/paperthin --skill backprop -a claude-code. The definition will be placed in ~/.claude/skills/backprop/SKILL.md.

What does the backprop skill do?

It identifies the causes behind an erroneous output and propagates structural updates back into the source rules, skills, or docs.

What does backprop require to operate?

It requires the re0-memo skill to detect lessons, and relies on companion skills like elon, ssotize, re0, debloat, and re0-order from the paperthin repository.

Source text

SKILL.md · MIT
---
name: backprop
description: "Feed what a finished cycle taught back through the sources that produced it: measure the lesson, question the requirements it touches, land it in one owner, refresh that owner to a clean v0, cut its padding and realign its listings, each pass only when it applies. Use after a correction, a request the user had to repeat, a failed or disappointing cycle, or a cleanup pass over a repository's docs, rules or skills, when the lesson has to change the sources rather than sit in a memo."
---

Carry a lesson from the output back into the sources that produced it, then leave those sources clean.

## Goal

A correction says the output was wrong; the fix belongs in what produced it. Backpropagation in a network measures the error at the output and sends it back through every layer that contributed, each adjusting by its share. `backprop` does the same for a body of work: `re0-memo` measures the error and names its class, `elon` questions the requirements that let it through, `ssotize` puts the lesson in the one source that owns it, and `re0`, `debloat` and `re0-order` leave that source reading as its clean current version. The scope you name bounds every pass, each pass runs only when its condition holds, and the order stays fixed.

## Workflow

1. **Pin the scope.** Name the output the lesson came from (the correction, the failed cycle, the review finding) and the sources it implicates: the docs, rules, skills or code that produced it. If neither is named, propose the user's last correction and the files it concerns, and wait for a yes before editing; with no correction to propose, ask for the output and stop. Every later step stays inside this scope.
2. **Measure.** Call the Skill tool with "re0-memo" on the output. Its lessons, each a class with its evidence and the owner it names, are what the remaining steps carry back. When it finds no lesson, report that and stop.
3. **Question.** Call the Skill tool with "elon" on the requirements and rules in scope that the lessons touch. Skip it when the scope holds no requirement or rule. Stop at its approval gate; what the user approves is carried out, and what is declined stays as it was.
4. **Consolidate.** Call the Skill tool with "ssotize" so each lesson lives in the owner `re0-memo` named and every other copy in scope becomes a reference. Skip it when nothing in scope duplicates or contradicts a lesson. Stop at its approval gate; what the user approves is carried out, and what is declined stays as it was.
5. **Refresh.** Call the Skill tool with "re0" on each owner the steps above changed, so it reads as though the lesson had always been there. Skip it when no owner changed.
6. **Tighten.** Call the Skill tool with "debloat" on prose or code in scope that is correct and current but padded, AI slop included. Skip it when nothing is bloated.
7. **Realign.** Call the Skill tool with "re0-order" on each listing in scope whose order no longer follows one principle. Skip it when no listing drifted.
8. **Hand off punctuation.** If the changed text has em-dashes or look-alikes, ask the user to run `dedash` on it; if it has Korean prose or label rows joined by middle dots, `dedot`. Name the files to pass.
9. **Report** each step as ran, skipped with its reason, or handed off, and name each lesson with the owner it landed in.

## Rules

- Keep the order. The lesson comes first because every later pass carries it; requirements are questioned before anything is consolidated, so nothing is moved that should have been deleted; `ssotize` precedes `re0` because `re0` repairs from the canonical source; `re0` precedes `debloat` because `debloat` tightens prose that is already current; `re0-order` follows both because they may cut or merge the items it moves; punctuation comes last because every rewrite regenerates dashes.
- Run a pass only when its condition holds and state every skip. Running every member by default is a misuse.
- Run each pass once. When a later pass finds duplication or drift it does not handle, report it with its location instead of looping back.
- Use the members; never reimplement their procedures. Skip a member that is not installed and say so; without `re0-memo` there is no lesson to carry, so stop and say so.
- `dedash` and `dedot` are user-invoked, so this skill names them as handoffs and never runs them.
- Stop at the artifact. Never stage, commit or push.

## Verification

1. Every step reports ran, skipped with a reason, or handed off; none is silent.
2. Every lesson `re0-memo` produced either landed in its owner or is reported with why it did not.
3. Every edit lies inside the pinned scope, and the passes ran in the stated order.
4. Each changed owner reads as its clean current version, with no lesson appended to a neighboring sentence.

© LilMGenius · MIT · LilMGenius/paperthin

Similar skills

All skills for Agent setup: memory, context, orchestration →

backprop by other authors comes first.

backprop JuliusBrussee backprop turns bug fixes into specification updates in SPEC.md. The agent traces the failure, drafts a testable invariant, adds a failing test, and commits everything together. CX Codex +1 2,600installs documenting-legacy-codebases riekelt documenting-legacy-codebases rebuilds documentation from the code itself when the existing docs are missing, stale or untrusted. Survey first, prose second. CX Codex +1 26,600installs improve-code-quality wondelai improve-code-quality — a skill for Claude Code and Codex guides untested code toward production stability. It runs an interactive nine-phase workflow and records every milestone in local markdown files. CX Codex +1 2,700installs docs-cleaner daymade docs-cleaner — a skill that keeps documentation honest after code changes and merges redundant files without losing what mattered. CX Codex +1 1,100installs om-create-skill open-mercato om-create-skill turns a brief into a new OM skill or refactors an oversized SKILL.md into layered references/ files. The split path is conservative: text moves 1:1, behavior stays intact. CX Codex +1 4,000installs speckit-baseline dceoy The speckit-baseline skill reads your source files and turns them into a framework-agnostic feature spec with user stories and requirements. Useful when a codebase exists but written requirements do not. CX Codex +1 1,600installs architecting-solutions zhaono1 architecting-solutions guides the AI through technical design and refactoring workflows, saving structured architecture briefs into docs. Built for engineering tasks where a PRD is not needed. CX Codex +1 924installs

From the same set48

The whole set →
whychk whychk — a skill for Claude Code and Codex that challenges freshly made choices. An isolated sub-session identifies unstated assumptions, demanding explanations one gap at a time. CX Codex +1 123installs re0-decide re0-decide — a skill for Claude Code that turns proposal materials into a traceable decision instrument without recommending outcomes. CX Codex +1 123installs re0-squash The re0-squash Claude Code skill condenses a GitHub repository into one signed commit, then recreates its remote. It runs on an explicit request to replace a repository’s history. CX Codex +1 123installs scopechk scopechk is a Claude Code skill that checks whether an item falls within a target repository scope. Run it before adding or moving a module into a repository. CX Codex +1 123installs re0-import re0-import — a Claude Code skill routes handed-over material into documents in an existing knowledge base. It follows that base’s own routing rules for notes, links, and corrections. CX Codex +1 123installs crossthink crossthink — a skill for Claude Code that borrows operational mechanisms from distant fields when technical options get stuck on a single blocker. CX Codex +1 121installs deid This Claude Code skill finds one person’s or organization’s data in a shared artifact and replaces matches with roles or placeholders. It runs before publication or when a repository needs de-identification. CX Codex +1 121installs paperthin Takes requests entered via /paperthin and forwards them directly to the re0-workflow router. CX Codex +1 120installs

Project sponsors

Companies that keep this analytics open