re0-loop — Claude Code skill: what it does, how to install
Drives repeated development loops through vertical slices, real-surface checks, and memo-based learning. Keeps projects focused on verified modules rather than code volume.
npx skills add LilMGenius/paperthin --skill re0-loop -a claude-codeWhat re0-loop does
re0-loop guides an agent through a disciplined turn: FRAME, BUILD, DRIVE, RE0-MEMO, HATE, and RE0-WORK. Progress is measured by quality-cleared templates and eliminated anti-patterns, not accumulated files. The agent first establishes a thesis, then builds a single vertical slice. Unit tests serve as supporting proof, but real-surface validation is mandatory. For web projects this means a browser run, while APIs require real HTTP requests.
At the end of the pass, re0-memo captures lessons and next-cycle gates. When the next action is uncertain, nba reads the state and returns one specific step. An adversarial review skill or human attack must challenge the upcoming plan before building restarts. Only cleared modules receive version labels. A restart that retains key lessons counts as forward motion, so unverified code is allowed to die.
What it helps with
- enforce agent progress via vertical slices and real-surface verification
- record anti-patterns and rules between cycles using
re0-memo - challenge new plans before building through adversarial review
- prevent unverified modules from receiving version labels
Example prompts for the agent
- Run re0-loop for the first vertical slice of our API.
- Execute the DRIVE step in a browser and verify the slice.
- Run re0-memo to record anti-patterns before planning the next lap.
How to install re0-loop
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-loop -a claude-code2Manually: put the files in place
~/.claude/skills/re0-loop/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/re0-loop/
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-loop -a codex2Manually: put the files in place
.agents/skills/re0-loop/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-loop -a cursor2Manually: put the files in place
.cursor/skills/re0-loop/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install LilMGenius/paperthin re0-loop2Manually: put the files in place
.github/skills/re0-loop/SKILL.md1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-loop -a gemini-cli2Platform CLI
gemini skills install https://github.com/LilMGenius/paperthin --path skills/coil/re0-loopManually: put the files in place
.devin/skills/re0-loop/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-loop -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about re0-loop
How do I install re0-loop in Claude Code?
Run npx skills add LilMGenius/paperthin --skill re0-loop -a claude-code in your terminal. The skill file is placed in ~/.claude/skills/re0-loop/SKILL.md.
What does re0-loop do?
It runs a development cycle spanning framing, building, real-surface testing, and post-run analysis. Progress is tracked through cleared templates and eliminated mistakes rather than lines of code.
What verification is required before finishing a lap in re0-loop?
The cycle requires captured proof from the real surface and updated lessons in re0-memo with an explicit decision on whether to iterate or restart.
Source text
SKILL.md · MIT
--- name: re0-loop description: "Run repeated build -> QA -> re0-memo -> re0-work cycles 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 the cycle so learning compounds and code accumulation does not masquerade as progress. ## Goal `re0-loop` keeps a project moving through repeated turns: ```text FRAME -> BUILD -> DRIVE -> RE0-MEMO -> HATE -> RE0-WORK -> BUILD AGAIN ``` The unit of progress is not hours, files, panels, or features. It is the count of quality-cleared templates, reusable platform modules, and anti-patterns eliminated in later cycles. ## Workflow 1. Frame the thesis and quality gates. 2. Build one complete vertical slice. 3. Drive it through the real surface: browser for web apps, HTTP for API contracts, computer-use for desktop apps, and CLI only for data-shaped artifacts. 4. Run `re0-memo` to extract lessons, anti-patterns, and next-cycle gates. 5. Decide whether the next pass iterates in place or uses `re0-work`; when that call or the next move is unclear, `nba` reads the cycle state and returns the single next action. 6. Kill the next plan before build: use the project's adversarial review skill or a human-invoked attack when that skill is user-only. 7. Version only templates or modules that clear their gates. ## Rules - Tests are supporting evidence, not the gate; every turn needs a real-surface proof sized to the artifact. - Do not widen before the core loop clears. - Do not confuse generated variety with structural variety. If many outputs converge to the same shape, the cycle failed the variety gate. - Preserve negative corpus so later cycles can prove the same anti-pattern is gone. - Let code die. A restart that preserves the right lessons is progress. - Stop a lap when no outside truth enters; add evidence before another internal pass. ## Verification Before finishing a lap: 1. The real surface was driven and evidence was 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 belongs only to a quality-cleared template or module.
© LilMGenius · MIT · LilMGenius/paperthin
