Luban (luban-skill): an agent workshop that polishes an existing Skill before you ship it

What Luban actually solves, and for whom

Luban targets a specific failure that shows up after a Skill already works for its author. The README lists the symptoms plainly: you push it to GitHub and nobody installs it, the README reads like an engineering spec with no first-screen hook and no artifact worth screenshotting, you claim the effect is good but cannot reproduce the evidence, and when you do want to improve it you do not know whether to touch the trigger phrases, the workflow, or the examples.

The intended user is someone who has already written a SKILL.md and used it. Luban is not a scaffolding tool and it does not generate a Skill from a description. The repository ships one workflow file, skills/luban/SKILL.md, plus a case study in skills/luban/examples/ai-news-radar-case.md. Everything else in the tree is packaging: .claude-plugin for the Claude Code marketplace listing, assets for the demo GIF and the recording script.

That narrow scope is the point. The README's framing is that a working Skill is raw material, and the workshop decides whether it deserves to be carved at all.

The five actions: 验料, 访行, 过尺, 慢刨, 回炉

The workflow is five named actions, and the ordering matters more than the names.

验料 comes first and is adversarial. The agent challenges whether the Skill's premise holds, and the README states outright that if it is not worth polishing, Luban says so. This is the step most rewrite tools skip, and it is the reason Luban can refuse the job.

访行 sends the agent to the network to find comparable Skills and locate the niche. The README's rule is that the peer comparison table carries URLs, so the positioning claim is checkable rather than asserted.

过尺 applies three measures: structure, live testing, and what the README calls the living check. The stated principle is that a green CI can lie, so the agent is expected to pull real artifacts and reconcile them against the claim. The ai-news-radar case is the illustration: the living check found a data pipeline that had silently stopped for eight days underneath passing Actions, caused by a missing entry in a git add whitelist.

慢刨 freezes a baseline and only keeps a change if it passes a validation gate. The README is explicit that a change which fails the measure gets reverted, and that the agent should not carve extra just to look busy.

回炉 is the post-release step: leave a comparison watchlist and re-enter from feedback next round.

Installing Luban and running the first audit

The README gives one-line installs for three paths. The generic one uses the skills CLI and installs globally:

npx skills add LearnPrompt/luban-skill -g

Claude Code users can go through the plugin marketplace instead, which the README notes updates automatically:

/plugin marketplace add LearnPrompt/luban-skill
/plugin install luban

Hermes Agent users have a dedicated command:

hermes skills install LearnPrompt/luban-skill

The manual route clones the repository and copies the skill directory into the Hermes skills tree:

git clone https://github.com/LearnPrompt/luban-skill.git /tmp/luban-skill
cp -r /tmp/luban-skill/skills/luban ~/.hermes/skills/productivity/luban

After installing, you address the agent in natural language and hand it the target: a Skill directory, a GitHub repository link, or the SKILL.md contents. The README's example phrasing is to ask Luban to look at your skill. What you should see, according to the README, is the agent completing 验料, 访行, positioning and 过尺, then offering three polishing directions with one recommendation, and stopping. The README states it will not change a single line before you pick a direction.

The repository also documents an acceptance test. Point Luban at https://github.com/anthropics/skills and a passing run produces a 验料 challenge plus a URL-bearing peer comparison, three directions, and a stop. If it starts rewriting immediately, the install is not behaving as documented.

The four stop points and why they are the strongest part of the design

The safety section lists mandatory stop points: proposing a repositioning, merging to the default branch, tagging a release, and deploying anything visible to real users. Each waits for explicit authorization, and the README adds a sharp clause: a question from you, such as asking whether it is all done, does not count as authorization.

That clause is unusual and worth taking literally. Most agent workflows treat a conversational nudge as consent. Luban's documentation treats it as noise.

Two more constraints are stated. Credentials and private paths (API keys, tokens, cookies) must not appear in any public artifact. And changes must land as auditable commits, with the README ruling out brute-force rollback such as git reset --hard.

The trade-off is friction. A workflow that stops four times and refuses to infer consent from a friendly question will feel slow if you wanted a single pass. That is a deliberate cost, and the README does not pretend otherwise.

What the ai-news-radar case does and does not prove

The README's headline evidence is one engagement: taking ai-news-radar from v0.6 to v0.7.0 in a single conversation, with four pull requests merged. The reported outcomes are specific. The living check caught the eight-day silent stall. A scoring fix was validated by replaying 83,725 historical records, which removed 327 false AI items with no false positives reported. The share of a single source in the featured section moved from 15 of 20 to 4 of 20. First-screen rendering dropped from 806 to 523 cards and page height fell 30 percent. The comparison script became a repository tool, backtest_scoring.py, and the project adopted a rule that any scoring change must ship with at least 14 days of replay.

Every number is linked to a pull request in the case file, which is a stronger evidence standard than most Skill repositories offer. But it is still one project, written by the same organization that publishes Luban, and the README does not present a second independent case. Treat the numbers as a worked example of the method, not as a benchmark for what Luban will do to your Skill.

The 14-day replay rule is also the most portable idea in the repository. It is a project-level rule, not a Luban feature, and it only makes sense for Skills whose output can be scored against history.

Where Luban is the wrong tool

Luban assumes a Skill that already exists and runs. If you are starting from a blank directory, the first action has nothing to challenge and the three measures have nothing to measure. The README offers no scaffolding path, so a generator or a template is a better starting point.

访行 requires network access. The peer comparison is supposed to carry URLs, and the niche judgment depends on it. In an offline or air-gapped environment that action degrades, and the positioning output becomes the model's opinion wearing a table. The README does not document a fallback for this case.

慢刨 requires a frozen baseline and a validation gate. If your Skill has no reproducible output, no historical data, and no artifact a script can compare, the gate has nothing to admit or reject. You can still run the audit, but the acceptance step collapses into judgment.

The README also does not document rollback beyond the ban on git reset --hard, and it does not describe how the four stop points behave when the agent is running unattended. Those are gaps a careful adopter should confirm in SKILL.md before relying on them.

Luban versus asking the agent to tidy up the prose

The README draws its own comparison against the default behaviour of asking an agent to make a Skill look better. The differences are structural rather than stylistic.

A plain rewrite starts from the copy. Luban starts by questioning whether the Skill should exist. A plain rewrite is justified by the model's taste. Luban is justified by a peer table with URLs and a three-part score with evidence. A plain rewrite edits everything at once, which makes attribution impossible. Luban freezes a baseline, keeps one face per commit, and only retains a change that clears the gate. A plain rewrite ends with a subjective verdict. Luban ends with a replayed number, a tool committed to the repository, a written project rule, and a re-entry list.

The closest documented relatives are named in the acknowledgements rather than treated as competitors: microsoft/SkillOpt for frozen baselines, bounded candidate edits and validation-gated acceptance, alchaincyf/darwin-skill for the evaluate, improve, test, keep-or-rollback loop with an independent judge, and KKKKhazix/khazix-skills hv-analysis for the vertical-and-horizontal scan behind 访行. If you only want a critique of your Skill's prose, hv-analysis is the lighter instrument. If you want a ratchet that keeps only measured improvements, SkillOpt and darwin-skill are the direct ancestors and worth reading before you adopt Luban's version of the same loop.

Maintenance, licence, and what an upgrade costs you

The repository is not archived. The last push was on 2026-07-10, and v2.1.0 was tagged the same day, so the project has been quiet for roughly two months. That is recent enough that the workflow is unlikely to have drifted far from the documentation, but the README does not state a release cadence or a support commitment, and there is no roadmap in the tree.

The code is MIT licensed, which permits commercial use, modification and redistribution. The README's own gloss on the licence is permissive. Note that the licence covers the repository contents; it does not govern the Skills you run Luban against, and the README does not discuss that boundary.

The upgrade surface is small. The repository contains one workflow file, one case file, assets and the plugin manifest. CHANGELOG.md sits at the top level, so version-to-version changes should be traceable there. The real upgrade cost is behavioural rather than technical: if a future release changes the stop points or the validation gate, you need to re-read SKILL.md, because those are the parts you rely on when you hand the agent write access to a repository you care about.

Editorial conclusion

Adopt Luban if you already have a working Skill that nobody installs, and you want a documented audit before you touch the prose. Skip it if your Skill is still an idea, if you want a one-pass rewrite, or if you cannot give the agent network access for the peer benchmarking step. Before installing, read skills/luban/SKILL.md to confirm the five actions and the nine-step flow match what you expect, and check the ai-news-radar case file to see whether its evidence standard is one you can meet.

Frequently asked questions

Official sources

1. Issues
2. LearnPrompt/luban-skill on GitHub
3. License: MIT
4. README
5. Releases