Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

re0-loop

Run repeated cycles of build, QA, re0-memo and re0-work while preserving learning and letting code die. Use for long agentic projects where progress must be measured by quality-cleared templates, reusable modules, and eliminated anti-patterns rather than hours spent or features accumulated.

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-loop

About this skill


name: re0-loop description: "Run repeated cycles of build, QA, re0-memo and re0-work while preserving learning and letting code die. Use for long agentic projects where progress must be measured by quality-cleared templates, reusable modules, and eliminated anti-patterns rather than hours spent or features accumulated."

Run a long project through repeated laps of the coil cycle so learning compounds and code is free to die.

Goal

Keep a long project moving through repeated turns so learning compounds and piling up code never passes for progress. Use it on long agentic projects where progress must be measured by quality-cleared output rather than time or feature count. Progress counts only as quality-cleared templates, reusable platform modules, and anti-patterns eliminated in later cycles; never hours, files, panels, or features.

Each lap runs this cycle:

FRAME -> BUILD -> DRIVE -> RE0-MEMO -> HATE -> RE0-WORK -> BUILD AGAIN

Workflow

Run the steps in this order.

  1. Frame. Write the thesis and the quality gates the lap will be judged against.
  2. Build. Build one complete vertical slice.
  3. Drive. Drive the slice through its real surface, picked by artifact: a browser for web apps, HTTP for API contracts, desktop UI automation for desktop apps, and the CLI only for data-shaped artifacts. Capture what the drive shows as the lap's evidence.
  4. Memo. Call the Skill tool with "re0-memo" to extract lessons, anti-patterns, and next-cycle gates from the lap. The memo lands where that skill's own contract puts it.
  5. Decide. You decide whether the next pass iterates in place or restarts, and you state the choice as keep, iterate, or re0-work. For a restart, call the Skill tool with "re0-work". When that call, or the next move, is unclear, call the Skill tool with "nba", which reads cycle state and returns the single next action.
  6. Kill the plan. Attack the next plan before building it. Use the project's adversarial review skill. When that skill is user-invoked only, as hate is, the attack is the human's to fire: tell the human to run it, and never call it yourself.
  7. Version. Put a version label only on the templates or modules that cleared their gates. The next lap builds again from what survived.

Rules

  • Tests support; they are not the gate. Every lap needs a real-surface proof sized to the artifact.
  • Do not widen scope before the core loop clears.
  • Generated variety is not structural variety: if many outputs converge on one shape, the cycle failed the variety gate.
  • Preserve negative corpus so later cycles can prove an anti-pattern is gone.
  • Let code die: a restart that keeps the right lessons counts as progress.
  • A request the human makes while a lap runs goes onto the live plan the moment it arrives, beside earlier ones rather than over them, and leaves it only when it is done or the human drops it. A summary written when the context is compacted or handed to a new session lists every request still open, started or not, because a request held only in the conversation is lost with it.
  • Outside truth is evidence the lap did not produce about itself: a real-surface drive, a user's reaction, data from outside the build. A lap with none stops; add such evidence before running another pass rather than looping on itself.
  • Through the Skill tool, call only the model-invoked "re0-memo", "re0-work", and "nba". Route the plan attack to the project's adversarial skill, or to the human when that skill is user-invoked; never call a user-invoked skill.

Verification

Before closing each lap:

  1. The real surface was driven and evidence captured.
  2. The re0-memo names at least one lesson, anti-pattern, or gate that affects the next pass.
  3. The keep / iterate / re0-work decision is explicit.
  4. Any version label sits only on a quality-cleared template or module.

Delegated implementation: re0-memo

Source: https://github.com/LilMGenius/paperthin/tree/1306ea4a2c038b5dee508db23197b3a19ccfbdfc/skills/coil/re0-memo


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

Read the complete source ↗