# ClaudeSkills: 13 installable Agent Skills for Claude Code and other SKILL.md clients

> ClaudeSkills packages reusable working methods as SKILL.md folders, from deep research to deck production. The repository ships its own validators and contract tests, and it is honest about what those tests do not cover.

**staruhub/ClaudeSkills** — 13 curated Claude Code agent skills, decks, deep research, PRDs, articles, audits. Tested like software.

- Repository: https://github.com/staruhub/ClaudeSkills
- Stars: 721 · Forks: 130
- Language: Python
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/staruhub-claudeskills

## What ClaudeSkills solves, and who it is written for

The repository's own framing is the clearest statement of intent: a prompt lets a model do something once and then dies with the conversation, while a skill keeps the method around so it can be reused, inspected and improved. ClaudeSkills is a set of 13 such methods, each stored as files in the open SKILL.md format. Steps, templates, scripts, examples and acceptance checks are all part of the package rather than buried in a chat history.

The audience is narrow and specific. You need a client that supports Agent Skills, and you need to be willing to install files rather than paste text. The four flagship skills map to recurring knowledge work: deep-research scopes a question, gathers sources, registers each one and checks citations before handing back a report with references and stated limits; product-manager runs what the README calls grill-me-to-doc, reading the repo first, asking one question per round, and refusing to write code before the document is approved; deck-studio produces outlines, per-page briefs and registered layouts with visual checks; wechat-article-writer produces copy, image prompts and layout HTML and, by design, never publishes for you. The nine professional skills sit closer to engineering: pair-programming, security-audit, solution-architect, threejs-performance, mineru-pdf-parser, ai-sales-champion, keqian-method, xuefeng-method and c-drive-cleaner, the last of which is dry-run by default.

If your work is one-off and conversational, this collection adds installation overhead for little return. It pays off when the same procedure runs repeatedly and you want the procedure itself to be reviewable.

## How a SKILL.md package is structured and how it reaches the model

Each skill lives in its own directory under skills/, and the directory name is the skill name. The README states this explicitly in the manual-copy example, where the source folder is copied to a destination whose final path segment becomes the skill's identity. That convention matters because it means renaming a folder renames the skill.

The mechanism is file-based, not API-based. There is no server component described anywhere in the repository layout: the top-level entries are scripts/, skills/, tests/, verification/, lab/ and llm-wiki/, plus documentation files. Skills install to ~/.agents/skills/ by default, which the README says most clients scan. From there, activation depends on the client. The FAQ notes that triggers vary: some clients match natural language, others want slash commands, and the practical fallback is to name the skill in your request.

Verification is treated as part of the architecture rather than an afterthought. scripts/validate.py checks the directory structure of the 13 curated skills against the repo contract. scripts/run_routing_evals.py runs 91 routing cases across 10 skills and checks schema, target, uniqueness and conflicts. tests/task_b/run_contract_tests.py covers 17 fixed cases spanning the success, resume and failure paths of all four flagships, and for deck-studio it also runs real Chrome rendering and PPTX assembly. The README is unusually direct about the ceiling here: the contract tests do not prove output quality on a different model, real image generation, or actual WeChat publishing, and the routing evals do not prove routing accuracy when a real model runs it. That distinction between structural correctness and behavioural quality is the most useful thing in the documentation.

## Installing ClaudeSkills and running deck-studio for the first time

The quick start clones the repository shallowly and then invokes the installer with a short skill name. The installer writes to ~/.agents/skills/ unless told otherwise.

```bash
git clone --depth 1 https://github.com/staruhub/ClaudeSkills.git && cd ClaudeSkills
python3 scripts/install_skill.py deck-studio
```

To see every short name the installer accepts before committing to one, list them first.

```bash
python3 scripts/install_skill.py --list
```

The installer also accepts a project-scoped install and an explicit client directory. The latter is the escape hatch when your client does not scan the default location.

```bash
python3 scripts/install_skill.py deep-research --project
python3 scripts/install_skill.py deep-research --client claude-code
```

After installing deck-studio, the README's example request is a plain sentence naming the skill and the deliverable: use deck-studio to turn a quarterly review into an 8-slide consulting deck. What you should see is the skill's process being followed rather than a single blob of generated text: an outline, then per-page briefs, then registered layouts and visual checks. If nothing happens, the FAQ gives two causes worth checking in order. First, whether your client scans .agents/skills/ at all; if it does not, use the client's native directory. Second, whether the request named the skill. Naming it is the reliable trigger.

Updating and removing are both single commands, and the README is explicit that installed skills are copies, so a git pull alone does not update what the client loads.

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

## What the bundled checks do not prove

The verification section is the part most skill collections omit, and its own table is the strongest argument against over-trusting it. validate.py proves that the directory structure of the 13 curated skills matches the repo contract. It does not prove real-business end-to-end behaviour for every skill. run_routing_evals.py proves that 91 routing cases pass schema, target, uniqueness and conflict checks. It does not prove routing accuracy when a real model executes the routing. The Python and Node compile checks prove that the repo's 13 Python files and 7 JavaScript files parse. They prove nothing about network access, external tools or production availability.

That leaves a real gap between a green test run and a working skill in your environment. The contract tests explicitly exclude output quality on a different model, real image generation and actual WeChat publishing, which are precisely the areas where a user would want evidence. The self-test numbers in the README, a 7.1/10 on the repo's own rubric for the Constructivist example and a 42.3 to 29.7 result in a position-swapped three-judge comparison, come with the rubric and data in the repository so they can be rerun. They are still the project grading itself against its own standard, and a rubric authored alongside the artifact is a weak form of external validation.

There is also a scope boundary the README draws clearly. The experimental skills in lab/, described as exam prep, weather reports and podcast generation, do not count toward the curated 13 and skip the same checks. If you install from lab/, you are outside the verified set.

## ClaudeSkills compared with prompt libraries and agent frameworks

The closest thing to a competing approach is a prompt library: a collection of text you paste into a conversation. The difference in mechanism is that a skill is a directory of files with an install path, templates, scripts and acceptance checks. A prompt library cannot be structurally validated because there is no contract to validate against, and it cannot carry a script that runs during execution. ClaudeSkills' validate.py and contract tests only exist because the artifact is a package rather than a paragraph.

The other comparison is with agent frameworks, which typically orchestrate multi-step execution in code you write and host. ClaudeSkills does not do that. It installs method files into a directory your existing client already reads, and the client remains responsible for triggering and execution. That is a smaller commitment and a smaller capability. If you need deterministic orchestration with your own state management, a skill package is the wrong layer.

Within the repository there is a third distinction worth noting for anyone choosing between the flagships. product-manager is explicitly gated: no code before the doc is approved, and interruptions resume. wechat-article-writer is explicitly bounded: it never publishes for you. Those are deliberate constraints that make the skills usable in a review process, and they also mean the skills will refuse work a more permissive prompt would attempt.

## Maintenance, updates and what the MIT licence leaves to you

The repository is not archived, and the last push was on 2026-08-12, the same date as the 1.0.1 release. Version 1.0.0 landed on 2026-08-03, so the two releases are nine days apart, which is a short window to read as a settled cadence. There is a CHANGELOG.md and a validate.yml workflow in .github/, so structural checks appear to run in CI, but the README does not describe a support policy, a compatibility matrix, or which client versions each skill was exercised against.

Upgrade cost is low but manual. Because installed skills are copies, the update path is git pull followed by reinstalling with --force, and uninstalling is a directory removal. There is no version pinning mechanism described for installed skills, so a pull brings whatever main currently holds. The README does not document rollback to a previous skill version, which is the gap to plan around if you depend on a specific behaviour.

The licence is MIT, which is permissive and places few obligations on reuse. That is a statement about the licence text, not advice about your situation. Two practical consequences follow from the file-based design: the repository includes a SECURITY.md, and one of the curated skills, security-audit, reviews code and dependencies for security issues, so installing it means pointing an automated reviewer at your codebase. Whether that fits your policies is a decision the licence does not make for you.

## Conclusion

Adopt ClaudeSkills if you already run a client that scans ~/.agents/skills/ and you want a repeatable method, not a one-off prompt, for research, decks, PRDs or audits. Skip it if you need a hosted marketplace, guaranteed model-triggered activation, or published evidence of output quality on your own model. Before rolling it out, run python3 scripts/validate.py and python3 tests/task_b/run_contract_tests.py in a clone, then read the verification/2026-07-31/README.md record to see exactly which paths were exercised.

## FAQ

### What do ClaudeSkills skills actually do?

Each skill packages a complete process rather than a single answer: steps, templates, scripts, examples and acceptance checks are all files. The 13 curated skills cover research, product documents, decks, WeChat articles, pair programming, security audits, architecture, Three.js performance, PDF parsing, sales explanation, two product methods and Windows C-drive cleanup.

### How do I install ClaudeSkills from GitHub?

Clone the repository and run the installer with a skill's short name, for example python3 scripts/install_skill.py deck-studio. Skills install to ~/.agents/skills/ by default, and the installer also accepts --project and --client flags for other locations.

### How do I use ClaudeSkills in Claude Code?

Install the skill with python3 scripts/install_skill.py deep-research --client claude-code, which targets Claude Code's directory. Then name the skill in your request, since the README notes that triggers vary by client and naming the skill is the reliable way to activate it.

### How do I use ClaudeSkills in Cursor, VS Code or Copilot?

The README does not give per-client instructions for these editors. It states that skills install to ~/.agents/skills/, which most clients scan, and that if your client does not scan that directory you should use its native directory instead.

### How do I use ClaudeSkills in GitHub Copilot?

The README does not document a Copilot-specific path. The general rule it gives is that skills install to ~/.agents/skills/, which most clients scan, and that a client which does not scan that directory needs its own native directory instead.

### How do I use ClaudeSkills in VS Code?

The README gives no VS Code-specific instructions. It only states the default install location, ~/.agents/skills/, and that clients which do not scan that directory must be pointed at their native skills directory.

## Sources

- [Official README](https://github.com/staruhub/ClaudeSkills#readme)
- [Project repository](https://github.com/staruhub/ClaudeSkills)
- [Release notes](https://github.com/staruhub/ClaudeSkills/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/staruhub-claudeskills