re0-memo
Turn a finished, failed, or disappointing work cycle into portable lessons, anti-patterns, quality gates, and next-cycle vocabulary, and measure how far the work stands from its objective. Use after a build, QA pass, demo, user complaint or correction, a request the user had to repeat, a user asking why something was not done, a lesson whose own fix caused a new failure, or an abandoned attempt, and always before a restart from v0, when the useful output is what the next pass must learn rather than the code itself.
LilMGenius · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add LilMGenius/paperthin --skill re0-memoAbout this skill
name: re0-memo description: "Turn a finished, failed, or disappointing work cycle into portable lessons, anti-patterns, quality gates, and next-cycle vocabulary, and measure how far the work stands from its objective. Use after a build, QA pass, demo, user complaint or correction, a request the user had to repeat, a user asking why something was not done, a lesson whose own fix caused a new failure, or an abandoned attempt, and always before a restart from v0, when the useful output is what the next pass must learn rather than the code itself."
Pull a work cycle's durable lessons into the docs the next pass starts from.
Goal
re0-memo pulls durable lessons out of a work cycle without defending what the cycle built. A cycle can run and pass its tests while still building the wrong thing, so the tests are not the verdict. Record three things, each with local evidence: what worked, what misled the build, and which gate the next pass must clear. The output is neither a changelog nor a therapy note.
Use it when an artifact is done, failed, disappointing, or ambiguous enough that the next agent needs the cycle's lessons more than its momentum: after a build, a QA pass, a demo, a user complaint or correction, a request the user had to repeat, a user asking why something was not done, a choice the user had to make that a written default should have made, or an abandoned attempt. Each of these means the user supplied what the work should have supplied itself, so run it in the turn the sign arrives, before the interrupted task resumes and buries it.
A restart from v0 always runs it first. The memo is the restart's map: what the old cycle got wrong and how far it actually stands from its objective, so the restart aims at the measured gap rather than at the old plan's picture of itself.
A lesson fails in two ways besides being wrong. It stays too narrow, so the same failure returns through another tool, surface or actor and nothing fires; or its fix is itself a member of the failure's class, so landing it causes the next failure. The workflow climbs each lesson to the widest class that still holds, searches that class's siblings, and tries to break each prescription before it lands.
It calls four other skills: detool to strip tool, product and person names from a lesson, crossthink when every drafted prescription takes one route, elon to question the drafted prescriptions, and scopechk to place each lesson. It carries two moves of user-invoked skills inline, since no skill can call those: the larger-scale re-read of one decision from macrothink (input: the decision and its boundary; output: what changes once the boundary moves), used to find siblings and the actor rung, and the first nail of hate (input: a plan; output: its load-bearing assumption and the cheapest experiment that would break it), used on each prescription. A step's fallback for a missing skill applies too when the host has no Skill tool, and the memo records each fallback that ran as manual: <skill>. Its field-coverage check follows the failure taxonomies reference. Its output feeds the next cycle, read by a fresh agent who never saw this one.
Workflow
Run the steps in order.
- Read the original objective, the final artifact, QA evidence, user complaints, and any local planning notes.
- Measure where the work stands against its objective from the records it left (outcomes, counts, money, what users actually received), never from the plan or the commit log. Place it on a ladder of capability levels when its field has one, such as driving automation's levels for an autonomous agent, and name both the level it was built for and the level it measures at; a cycle that did worse than doing the work by hand measures below the bottom, which the memo says only when the records show the hand result; otherwise it writes the comparison as unmeasured.
- Sort what earned reuse (contracts, schemas, tests, services, vocabulary, examples) apart from what only looked productive (UI, panels, scaffolds, abstractions).
- Cluster the specific complaints into the pattern they share; many complaints across many items usually trace to one root gap, and a single complaint is a cluster of one. Write nothing yet.
- Climb the generalization ladder from each cluster, one line per rung: the lesson stated at that rung, whether the cycle's records and the repository hold a counterexample, and that counterexample when they do. The rungs, from the bottom: the case as it happened; its siblings inside the same tool, platform or surface; the mechanism with every tool, product and person name removed, for which you call the Skill tool with "detool" on the rung's sentence, or remove the names yourself when it is not installed; the actor generalized to any receiver, a role that holds or lacks a capability, a permission and a duty whoever fills it, so the lesson names the role and never lists kinds of receiver; and the field's known failure class, which step 7 checks against saved sources. The lesson is the highest rung that holds with no counterexample, and the counterexample one rung above it is written beside the lesson as the class's boundary. When the top rung holds, write its boundary as
none observed; never invent a counterexample. A rung so general that it no longer names something the next agent can check is past the top. - Search the class's siblings by re-reading the decision that failed at a larger scale, as the Goal describes: across the repository, the documents that hold its rules, and the other actors and surfaces the work touches, list every place the class can strike, each with its path and whether it already failed, is one step from failing, or is covered. A rule that already owns the class but whose wording reaches only part of it (one kind of actor, one surface, one tool) is a sibling too, and the reason it did not fire.
- Check the memo's classes against the field when