re0-order — Claude Code skill: what it does, how to install
A Claude Code skill, re0-order rearranges entries under one clear rule without editing their wording. It acts on a list the user names or passes through a requested pipeline.
MIT 130 installs ★ 1,470 updated 2026-10-25
npx skills add LilMGenius/paperthin --skill re0-order -a claude-codeWhat re0-order does
re0-order rearranges a list, table, catalog, section set, or enum. It selects a single ordering rule, such as dependency, workflow stage, item type, or alphabetical order. If the existing sequence may be deliberate, the skill asks for a decision before moving anything.
Items move in place; none are rewritten, added, or dropped. The same sequence is applied to matching copies, including translations. To locate those copies, the skill searches the repository for item identifiers or distinctive wording.
Before moving an item, it checks that the item exists and reports a MISS if it does not. The node scripts/same-set.mjs utility checks that the set remains unchanged and compares mirrored copies. Node.js is needed to run that check; for large structural changes, the skill recommends using a script.
What it helps with
- sort list entries by workflow stage
- group related table rows
- order sections by dependency
- match item order across translated copies
Example prompts for the agent
- Reorder the sections in
docs/guide.mdby workflow stage without changing their wording. - Group this catalog by item type and apply the same order to its translations.
- Check whether the order in
README.mdis deliberate; if not, suggest one sorting rule.
How to install re0-order
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-order -a claude-code2Manually: put the files in place
~/.claude/skills/re0-order/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/re0-order/
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-order -a codex2Manually: put the files in place
.agents/skills/re0-order/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-order -a cursor2Manually: put the files in place
.cursor/skills/re0-order/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install LilMGenius/paperthin skills/depth/re0-order2Manually: put the files in place
.github/skills/re0-order/SKILL.md1Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-order -a gemini-cli2Platform CLI
gemini skills install https://github.com/LilMGenius/paperthin --path skills/depth/re0-orderManually: put the files in place
.devin/skills/re0-order/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add LilMGenius/paperthin --skill re0-order -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-order
How do I install re0-order in Claude Code?
Run npx skills add LilMGenius/paperthin --skill re0-order -a claude-code. The skill file is at ~/.claude/skills/re0-order/SKILL.md.
What does re0-order do?
It rearranges a named set of items using one ordering rule while preserving its wording and contents. Matching copies receive the same sequence.
How does re0-order choose an ordering rule?
It can use a rule such as dependency, workflow stage, grouping by type, or alphabetical order. If the current sequence might be intentional, it waits for the user to decide before making changes.
Source text
SKILL.md · MIT
--- name: re0-order description: "Move items only, reword nothing; realign a listing whose order has gone arbitrary (a list, table, catalog, sections, an enum) into a logical sequence under one stated principle. Nothing is added or removed. Use when the user names a listing, or a scope holding one, whose order no longer helps a reader follow the set, or when a pipeline the user invoked passes that scope on. Acts only inside that scope." --- Move the items of a named listing into one order a reader can name, changing nothing but their positions. ## Goal A listing carries meaning when related items sit together along one clear axis; items appended where they happened to be written blur that. `re0-order` realigns the set under one principle a reader can name, moving items and changing nothing else. It acts on a list, table, catalog, set of sections, or enum the human named, or one inside a scope they named or a pipeline they invoked passes on. The result lands in place: in the listing itself and in every copy that mirrors it. ## Workflow 1. Pin the listing and its items: the ordered set in focus, inside the scope the human gave. 2. Name the one principle that makes the order most meaningful, from workflow or lifecycle sequence, dependency, grouping by kind, severity, frequency, alphabetical. If a latent order already exists, surface it and complete it instead of imposing a new one. When it is unclear whether the current order is deliberate, surface that call to the human and let them decide; move nothing until they do. 3. Put kin next to each other, then sequence those clusters by that one principle. 4. When the principle is a measured count (how often each item is used, how often it is searched), read each count from the record the listing serves and use it as a starting order, never as the sort key itself. Lead with the item the others are reached through, keep kin together even when their counts differ, let the reading or working order a newcomer follows decide the rest, and let the count settle only what that order leaves open. Name each place the result departs from the count and why. 5. Move items into the new order in place. Reword nothing; add nothing; remove nothing. 6. Apply the identical order everywhere the set is mirrored, translated copies and second surfaces included. To find the mirrors, search the repository for two or three of the set's items, by identifier where items have one and otherwise by a distinctive phrase, and for files that call themselves copies of this one, such as translations. Every hit holding the same set is a mirror and part of the listing the human named. ## Rules - Reorder only: never reword, add, remove, split, or merge an item. Those are other reflexes. - Use one principle a reader can name; never blend incompatible sorts in one listing. - Before sorting by that principle, place every item that another item depends on before it, and keep every precedence the human stated; a dependency constrains the sort and is never a second principle. An item that produces knowledge (research, a survey, a measurement) is depended on by every plan or build it would inform even when none of them names it, so it goes before them; its breadth or open end never sends it to the back, since what it finds late is work redone. - Respect a deliberate order: when the current sequence already encodes a real principle, complete and tidy it rather than replacing it, and surface the call when unclear. - Act only inside the scope a human named or that a pipeline they invoked passes on. Never choose a listing yourself; its order is the human's call, and a reorder reflex choosing its own target churns what nobody asked to move. - Mirrored copies of one set get the same order. - Edit safely: assert each item exists before moving it and report a MISS rather than dropping it silently; edit unicode-safe; script a large structural move instead of sweeping by hand. ## Verification Before finishing, confirm: 1. A reader can name the ordering principle from the result alone. 2. Every original item remains; only positions changed; nothing was reworded, added, or removed. Save the listing before the move and run `node scripts/same-set.mjs <before-file> <after-file> [--json]`: each non-blank line is an item, exit 0 means the same multiset, exit 1 names the added, removed or changed items, exit 2 is a usage error. 3. Kin are adjacent and the sequence follows the one principle end to end. 4. Every mirrored copy carries the identical order. Run the same script with `--mirror <file>` once per copy: it compares the items the copy shares with the after file and, on exit 1, names the first divergence.
© LilMGenius · MIT · LilMGenius/paperthin