CLI tool
staruhub/ClaudeSkills avatar
staruhub/ClaudeSkills

ClaudeSkills verifies its own skills and admits four things the checks cannot rule out

13 curated Claude Code agent skills, decks, deep research, PRDs, articles, audits. Tested like software.

738 stars129 forksPythonMIT

At a glance

What is it?
ClaudeSkills is a collection of 13 agent skill packages in the open SKILL.md format, with a script for installing them and three verification scripts for grading them. The interesting part is the table that states what each check does not prove, plus directory names that disagree with the skill names the installer takes.
Who is it for?
Use ClaudeSkills if you want a written process you can read and edit rather than a prompt you retype, and if you are willing to do the verification yourself, because the three scripts are cheap to run and honest about their limits. Do not treat the scores as validation: the flagship deck example scores 7.1 out of 10 on the project's own rubric, the routing evals never exercise a real model, and the recorded verification run predates release 1.0.1.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 94 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • staruhub/ClaudeSkills738 ★ · +91
Star history
Repository2026-07-312026-11-15
staruhub/ClaudeSkills647738

91 Stars in the last 107 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Directory names carry a Geek-skills prefix the installer never asks for

Every skill is presented under a short name and stored under a different one. The tables name `deep-research`, `product-manager`, `deck-studio` and `wechat-article-writer`, and the install commands take exactly those strings. The paths behind them all sit under a `Geek-skills-` prefix inside `skills/`, so the shipped directory is `skills/Geek-skills-deck-studio` while the thing you type is `deck-studio`. The prefix appears on every one of the 13 curated skills, which makes it a property of the collection rather than of one package, and nothing on the page explains where it comes from.

The manual copy line makes the mismatch explicit, and then glosses it. Its own trailing comment asserts that the directory name is the skill name, yet the command rewrites the name on the way in:

bash
python3 scripts/install_skill.py --list                  # list all short names
python3 scripts/install_skill.py deep-research           # install any skill
python3 scripts/install_skill.py deep-research --project # current project only
python3 scripts/install_skill.py deep-research --client claude-code # Claude Code's directory
cp -r skills/Geek-skills-deep-research ~/.agents/skills/deep-research # manual copy; the directory name is the skill name

The comment describes the destination, not the source. Anyone scripting against the repository layout has to know that `Geek-skills-deep-research` maps to `deep-research`, and anyone who assumes the prefix belongs to the installed skill will look for a directory that does not exist.

Routing accuracy is the one thing the routing evals cannot test

The verification section runs three scripts and then publishes a table of what each one proves and what it does not. That table is the most useful thing on the page, and the entry that deserves attention is `run_routing_evals.py`: 91 routing cases across 10 skills, passing schema, target, uniqueness and conflict checks. What it does not prove, in the project's own words, is routing accuracy when a real model runs it.

So the check that sounds most like a behavioural test is a static one. It confirms that routing targets are well formed, unique and non-conflicting; it says nothing about whether a model asked to research something picks deep-research over product-manager. `validate.py` is narrower still, checking only that the directory structure of the 13 curated skills matches the repo contract, with real-business end to end coverage named as out of scope. The Python and Node compile checks cover the repository's 13 Python files and 7 JavaScript files, proving only that they parse, with network access, external tools and production availability listed as outside what parsing can show.

The consequence is a specific one: every automated check in this repository is about the shape of the artifacts, and none of them is about the behavior of a skill when a model uses it.

The flagship deck example scores 7.1 out of 10 on the project's own rubric

The self-test numbers are published, which is unusual, and they are mixed. The Constructivist example scored 7.1 out of 10 on the repository's own rubric, and a position-swapped three-judge comparison came out 42.3 to 29.7. So the one example with a headline number is the one that scored below full marks on the scale the project wrote, while the comparison that shows a clear gap gives no scale definition, no judge model and no per-criterion breakdown in the overview.

The scoring record is dated. The full verification write-up lives at `verification/2026-07-31/README.md`, a directory named for the day it ran, while release 1.0.0 is dated 2026-08-03 and 1.0.1 on 2026-08-12, and the last push to `main` is 2026-08-13. The recorded run therefore predates the current release by twelve days and the current tree by thirteen, so the numbers on the page describe a slightly earlier state of the repository than the one you would clone.

What the project does give you is the basis to argue with it: the generators, rendered pages, rubrics and review notes stay in the repo, and four of the seventeen styles are linked by name, from Constructivist through a Moshiro consulting report, an Yinghuang bootcamp proposal and Polar Night AI Native. Re-running the comparison is presented as an option rather than a request.

Only deck-studio's contract tests touch a real browser

The contract suite is `run_contract_tests.py`, seventeen fixed cases across the four flagships, and its coverage is uneven in a way the page states plainly. Deck additionally runs real Chrome rendering and PPTX assembly. The other three flagships do not, and what they cannot cover is listed in the same cell: output quality on a different model, real image generation, and actual WeChat publishing.

That list lines up exactly with what each skill promises. deep-research scopes the question, gathers sources, registers each one and checks citations, then hands back a report with references and limits. product-manager runs a grill-me-to-doc loop that reads the repository first, asks one question per round, and refuses to produce code before the document is approved, with interruptions resuming. wechat-article-writer produces copy, image prompts and layout HTML, solo or as a pipeline, and never publishes on your behalf. deck-studio does outline work, per-page briefs, registered layouts and visual checks, and it is the only one whose output is a rendered artifact.

So the rendering test covers the skill whose output is pixels, while the three skills that produce text and files are graded on cases you read rather than render. Both the resume path and the failure path are included in the seventeen, which is more than most prompt collections attempt.

Installed skills are copies, so a git pull changes nothing on its own

The install FAQ states the update model in one line: re-install after `git pull`, because installed skills are copies. There is no symlink and no version pinning in the description, so the working tree and the installed copy drift apart the moment anyone clones at a newer commit. The documented repair is an explicit overwrite:

bash
git pull && python3 scripts/install_skill.py deck-studio --force   # update
rm -rf ~/.agents/skills/deck-studio                                # uninstall

Two things stand out. First, `--force` appears only in the update example and is never explained; a first time installer has no reason to know the flag exists until the second install fails to overwrite. Second, uninstall has no script. It is a raw recursive delete against `~/.agents/skills/`, which is honest and fast and gives you no confirmation prompt and no list of what it removed.

The default destination is `~/.agents/skills/`, chosen because most clients scan it, and the two flags that move a skill elsewhere are `--project` for the current project only and `--client` for a client's own directory. Anyone running this across a fleet of machines should expect to script all three of clone, force install and manual removal rather than rely on a single command.

One client name is given as an example and triggers vary by client

Discovery is the part this collection cannot own. Two separate failure modes are called out in the install FAQ. If a skill is installed but not found, the client may not scan `.agents/skills/` at all, in which case you use its native directory, which is what the `--client` flag is for. If there is no automatic trigger, the fix is to name the skill in your request, because triggers vary by client: some match natural language, others want slash commands.

That second point undercuts the premise of a skill library. The argument the project makes is that a prompt does something once and dies with the conversation while a skill keeps the method around, reusable and inspectable. Both halves are true, but whether the method is ever invoked automatically depends on the client, and the page names exactly one client value, `claude-code`, in the only example of the flag. The full set of client identifiers the installer accepts is not written down anywhere in what is shown, so discoverability here means cloning and reading `install_skill.py`.

The quick start reflects the same honesty, recommending a clone plus one install command and then telling your agent to use the skill by name, rather than promising automatic routing.

13 curated skills, a lab directory that skips checks, and a top-level llm-wiki nobody classifies

The count of 13 is precise and the page defends it: four flagships plus nine professional skills, with `validate.py` checking the structure of exactly those 13. Around that number sit three unclassified things. Experimental skills live in `lab/` and explicitly do not count toward the curated set and skip the same checks, so the number 13 is a statement about review discipline rather than about how much material is in the repository. The root also holds an `llm-wiki/` directory that the page never mentions, in either list, alongside `website/`, `assets/`, `design-qa.md` and `AGENTS.md`.

The nine professional skills show how little the collection assumes about the host environment. `mineru-pdf-parser` turns PDFs into Markdown or JSON and needs a local MinerU install, the only skill in the set with a stated external program dependency. `c-drive-cleaner` targets Windows C-drive cleanup and is dry-run by default, the only one with a stated destructive-action default. The rest are code review and architecture work: pair-programming writes code with structured self-review aimed at common AI code defects, security-audit reviews code and dependencies, solution-architect covers system design and tech selection, threejs-performance diagnoses and tunes Three.js performance, ai-sales-champion translates technical capability into business value, and two methods, keqian-method as a single-agent, SDD, quality-gated process and xuefeng-method as an open-behavior, model-driven one.

Two of the named methods and one of the example deck projects carry Chinese names, and the repository ships a `README.zh-CN.md` beside the English one, so this is a bilingual collection presented through an English index.

Editorial conclusion

Use ClaudeSkills if you want a written process you can read and edit rather than a prompt you retype, and if you are willing to do the verification yourself, because the three scripts are cheap to run and honest about their limits. Do not treat the scores as validation: the flagship deck example scores 7.1 out of 10 on the project's own rubric, the routing evals never exercise a real model, and the recorded verification run predates release 1.0.1. Two operational habits matter more than the content. Re-run the installer with `--force` after every `git pull`, because installed skills are copies, and check whether your client scans `.agents/skills/` before you conclude a skill is broken. Anything you plan to automate should go through the lab directory first, since those skills deliberately skip the checks.

Frequently asked questions

Where does ClaudeSkills install a skill by default?

To `~/.agents/skills/`, which most clients scan. The installer also accepts `--project` for the current project only and `--client` for a client's own directory, with `claude-code` the only client name given as an example anywhere in the docs.

How do I update a ClaudeSkills installation?

Installed skills are copies, so a `git pull` does not change them. The documented update is `git pull && python3 scripts/install_skill.py deck-studio --force`, and removal is a manual `rm -rf ~/.agents/skills/deck-studio` rather than an uninstall command.

What does the ClaudeSkills routing evaluation actually verify?

Schema, target, uniqueness and conflict checks over 91 routing cases across 10 skills. The project's own table states that it does not prove routing accuracy when a real model runs it, so every automated check here is about artifact shape rather than model behavior.

Why does a ClaudeSkills skill not trigger on its own?

Triggers vary by client, with some matching natural language and others wanting slash commands, so the fallback is to name the skill in your request. If the skill is not found at all, check whether your client scans `.agents/skills/` and otherwise use its native directory.

Does ClaudeSkills contain more than 13 skills?

The curated set is 13, four flagships plus nine professional ones, and that is the set `validate.py` checks the structure of. Experimental skills live in `lab/` and do not count toward the curated set, and the root also holds an `llm-wiki/` directory that the page classifies nowhere.

Which ClaudeSkills skill needs external software installed?

`mineru-pdf-parser`, which turns PDFs into Markdown or JSON and requires a local MinerU install. It is the only one of the 13 curated skills with a stated dependency on a program outside the repository.

Official sources

  1. Official README
  2. Project repository
  3. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/staruhub-claudeskills.svg)](https://hysenlabs.com/projects/staruhub-claudeskills)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/staruhub-claudeskills.svg)](https://hysenlabs.com/projects/staruhub-claudeskills)

Was this useful?