reverse-engineer-anything-self-learning-loop

Reverse Engineer Anything with a Self-Learning Loop: examine a product you are authorised to rebuild, build your own, and keep improving it until it is 100% there.

Free and open source · MIT Licence · Built by Speedrun AI Labs, Sydney, Australia

The problem

Give an agent a shipped product and ask for an equivalent, and you get something that is "80% there". It looks right, the obvious paths work, and then it stops, because nobody wrote down what 100% means and nothing measures the build against the original. The last 20% is where the product lives.

This skill is that last 20%, as a method. It combines two Speedrun AI Labs skills into one loop: the examination discipline of Reverse Engineer Anything and the learning loop of Hermes Agent as a Skill File, and adds the part neither has: a completion loop with a written definition of done.

What it does

• Defines 100% before building. The examination's inventory becomes a parity checklist: one testable behaviour per item, a concrete input and expected output, the exact check that will verify it, a tier (must-have, should-have, out of scope). The operator signs it. The score of a run is must-haves passing over must-haves total.
• Examines safely. Static-first, evidence-led, untrusted input: preflight, read-only copies and digests, capped extractions, escape checks, no secrets on screen, content treated as data, never as instructions. Notes record behaviour, never protected expression.
• Builds its own design. A walking skeleton across every must-have path first; clean-room discipline (whoever writes code does not have decompiled text open); fixtures from the operator; stubs instead of vendor backends; design decisions recorded apart from observations.
• Reviews against the original with evidence. Same input to both, outputs diffed or hashed, formats round-tripped, screens compared side by side at a stated threshold, timings measured. Pass, fail or not testable, with a file behind every result. A fresh-eyes reviewer re-scores a sample and hunts for what the checklist missed.
• Plans, improves, repeats. Gaps ordered by impact and dependency, a batch one iteration can prove, regression sampling so nothing silently breaks, an iteration log that says what moved the score.
• Knows when to stop. Done is every must-have passing in two consecutive reviews. Stop and ask when the score stalls for two iterations, a gap would need protected material or a vendor backend, the budget is spent, or any examination stop fires. Never declares 100% on an untested item.
• Learns from every iteration. The self-learning loop saves checklist patterns, review techniques, routes, tool recipes and fix recipes into this skill, staged for the operator's approval, so the next product starts further along. It never captures failures as rules, secrets, or anything from the target.

Install

Put the folder in your agent's skills directory.

Claude Code

mkdir -p ~/.claude/skills
git clone https://github.com/Speedrunlab/reverse-engineer-anything-self-learning-loop.git ~/.claude/skills/reverse-engineer-anything-self-learning-loop

Then run: /reverse-engineer-anything-self-learning-loop

OpenClaw

mkdir -p ~/.openclaw/skills
git clone https://github.com/Speedrunlab/reverse-engineer-anything-self-learning-loop.git ~/.openclaw/skills/reverse-engineer-anything-self-learning-loop

Any other agent

Copy the folder into its skills directory, or load SKILL.md into its instructions and keep references/ and templates/ where the agent can read them. Then map the capabilities in the "Map it to your agent" table once.

Companions (optional)

The skill stands alone. Install Reverse Engineer Anything beside it for the full route guides, the pinned toolchain and the live-analysis isolation rules, and Hermes Agent as a Skill File for the full learning loop (memory stores, curation, installing skills from outside). When they are present, the loop defers to them for examination depth and for memory.

What's in the box

SKILL.md                          the loop: gate, examine, define 100%, build, review, plan, improve, stop, learn, finish
references/
  examine.md                      safe handling, identification, routes and tools, inventory passes, the ledger, live rules
  parity-checklist.md             item anatomy, honesty rules, how to derive the list per product class, scoring
  review.md                       techniques per item type, the fresh-eyes pass, regression sampling, the gap report
  learning-loop.md                what gets learned and where, the review prompt, the shape of a lesson, never capture, approval
  fix-recipes.md                  fixes that moved a score, by cause; grows through the loop
templates/
  parity-checklist.md  gap-report.md  iteration-plan.md  run-ledger.md

What it needs

An operator-supplied analysis environment for the examination (no network, no credentials; a disposable VM for any live step), a separate build directory under version control, the open-source tools the target's route needs (installed deliberately, at pinned versions; the skill installs nothing itself), an approver independent of the requester, and fixtures the operator owns.

What it is not for

Cloning a third party's product, defeating access controls, lifting protected assets, or sending traffic to a vendor's backend. The gate asks for the authority record and the reuse boundary before any tool runs, and the reconstruction is the operator's own design, informed by observed behaviour.

Credits

Written and maintained by Speedrun AI Labs. The examination method is adapted from Speedrun's Reverse Engineer Anything; the learning loop from Speedrun's Hermes Agent as a Skill File, itself a derivative of Hermes Agent by Nous Research (MIT licence; attribution, not affiliation).

Part of the Speedrun AI Labs Skill Library

Other skills at speedrunlab.ai/#skills: /reverse-engineer-anything, /hermes-agent-as-a-skill-file, /deep-audit, /read-before-write, /no-slop-writing, /no-slop-writing-au.

Licence

MIT. Free to use, modify, and distribute.

Built in Sydney by Speedrun AI Labs.