# Yunshu SkillsHub is 27 Claude Code skills organised by the job, not the tool

> Yunshu SkillsHub is an MIT licensed collection of 27 Claude Code and Codex skills grouped into coding, thinking, learning, writing, visualization, brand and agent folders, each one a folder with a SKILL.md and supporting templates. It is a personal workflow library, so its value is the author's process rather than the code, and a few of the skills need a second tool installed on your machine.

**yunshu0909/yunshu_skillshub** — 云舒精选的 Claude Code Skills 集合，提升开发和产品管理效率

- Repository: https://github.com/yunshu0909/yunshu_skillshub
- Stars: 784 · Forks: 112
- Language: Python
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/yunshu0909-yunshu-skillshub

## A library of workflows, not a library of tools

Yunshu SkillsHub collects the Claude Code skills one person accumulated while working with AI every day. The stated idea is that after finishing a piece of work, the way the question was asked, the way the result was judged and the definition of done all get written down, so the next time the AI can follow the same method. The README is explicit that none of the skills were designed in the abstract, and that each one was used and revised in real work.

The repository advertises 27 skills and arranges them in category folders: coding, thinking, learning, writing, visualization, brand and agent. The coding group covers issue triage, page design, backend logic design, PRD and test case writing, dual model review, requirement change workflow, git push and release, issue pooling and open source repository search. The thinking group is smaller, with a thinking partner, a multi perspective analysis and a helper that picks the three most important things. Learning holds article study and systematic study, writing holds a writing assistant and a thought mining skill, and visualization holds case radar, image rendering, comic making, slide scenes and readable output.

The project is MIT licensed, the default branch is master, and the repository is not archived, with the last push on 2026-10-11. Tagged releases are sparse: v0.1.0 on 2026-05-18 and v0.0.1 on 2026-04-09. The primary language is listed as Python, which matches the scripts that ship inside some skill folders.

## The skill folder is the unit, and you are told to keep it whole

Every skill is a directory containing a SKILL.md file, and the category directories hold one folder per skill, so the layout is category/skill-name/SKILL.md. The README asks you to keep each skill folder complete when you install it, because the templates, the reference files and the scripts inside are part of the method rather than decoration. That instruction is not cosmetic advice: a SKILL.md that points at a template file which is no longer there leaves you with a workflow that describes steps it cannot perform.

The repository also carries a brand directory and an agent directory alongside the seven named categories, plus an assets directory holding the README imagery and case samples. Because the folder structure is the contract, updates are a manual affair. There is no version pin per skill and no manifest describing dependencies between skills, so when the author changes a skill, the only way to pick it up is to copy the folder again and trust that you took the new one.

That is a reasonable design for a personal collection that is expected to change, and it is a poor fit for a team that wants reproducible tooling. Nothing in the repository prevents two people on the same project from running different versions of the same skill.

## Installing with npx skills add, listing before you install

The command line route starts with a listing, so you can see what is on offer before copying anything into your home directory:

```bash
npx skills add yunshu0909/yunshu_skillshub --list
```

Installing selected skills to both tools at once looks like this:

```bash
npx skills add yunshu0909/yunshu_skillshub -g -a claude-code codex --skill thinking-partner writing-assistant
```

The global flag installs for the current user across projects, the agent list names both Claude Code and Codex, and the skill flag takes the names you chose. Taking everything at once uses a wildcard and skips the confirmation prompt:

```bash
npx skills add yunshu0909/yunshu_skillshub -g -a claude-code codex --skill '*' -y
```

There is also a conversational route. The README suggests pasting a prepared message into Claude Code or Codex that asks the agent to install the skills from the repository at user level, list every skill with a one line description for you to pick from, keep each folder intact and report back what was installed and where. The point of that phrasing is the same as the listing flag: choose before you install, rather than ending up with a directory you did not want.

After installation you use a skill by naming it or by describing the task, and the README asks you to keep the full folder because the templates and scripts are part of the method.

## Manual install copies the folder into your skills directory

If you would rather not use the npx route, the manual path is a clone and a copy. Claude Code reads from ~/.claude/skills, and Codex reads from ~/.agents/skills:

```bash
git clone https://github.com/yunshu0909/yunshu_skillshub.git
cp -R yunshu_skillshub/thinking/thinking-partner ~/.claude/skills/   # Claude Code
cp -R yunshu_skillshub/thinking/thinking-partner ~/.agents/skills/   # Codex
```

For the whole collection, the README loops over every SKILL.md it can find and copies the containing directory, one level under each category:

```bash
for f in yunshu_skillshub/*/*/SKILL.md; do cp -R "$(dirname "$f")" ~/.claude/skills/; done
```

The copy has to be recursive. A single skill folder holds more than its SKILL.md, and a flat copy of the markdown file alone would leave the skill without its supporting files. The same applies to the target directory, which the README creates with mkdir -p before the loop.

One wrinkle is worth planning for. When you copy the whole tree this way, skill names land flat in ~/.claude/skills rather than in category folders, so two skills with the same name in different categories would collide, and your directory listing will not show the grouping that the repository uses.

## Several skills need a second tool on your machine

This is the part of the collection that decides whether it works for you, because a number of skills delegate to another program. The README notes that dual-agent-collaboration requires both Codex and Claude Code installed locally, and that the git-push skill needs a logged in gh when it cuts a release. The reasoning is that the value of those two skills comes from running two independent agents over the same change, and from letting the release step run through the GitHub CLI rather than by hand.

The visualization group has the same shape of dependency. The image rendering, comic making and slide scene skills use the image generation built into Codex, which means Codex CLI must be installed and signed in through a Codex subscription. The README explains the division of labour: in either tool you can run these skills, and when Claude Code handles the design of a frame, the actual rendering is handed to Codex.

Two output constraints are stated as well. The slide skill produces one 16:9 image per page and the README is explicit that these are pictures, not an editable .pptx file. The comic skill produces a 3:4 vertical comic and accepts a character image so the teacher can be your own character.

Install the collection with that in mind. Copying twenty seven folders into your home directory costs nothing, but the skills that read a missing CLI will fail at the moment you need them.

## What the skills produce when they work

The interesting difference between this and a prompt list is that each skill names a concrete artefact. The issue pool skill turns scattered ideas, user feedback and bug reports into an ISSUES.md file plus issue definitions that are ready to work on. The PRD and test case skill produces a requirement document and a matching set of test cases, paired one to one. The requirement change workflow gives an impact analysis, a minimal change and a regression checklist, and the issue triage skill produces a root cause judgement, a handling recommendation and a drafted reply.

The learning skills are specific too. Article study turns a document into lecture slides, a quiz and a review of the mistakes made, while systematic study builds a knowledge map of an unfamiliar field with sources, cases and the points of disagreement. Multi perspective analysis is described as producing several independent lines of reasoning, then a shared conclusion, the disagreements between them, and blind spots.

The visualization skills are the most concrete of all. The image rendering skill offers 28 styles, each with a sample, and asks you to pick one on first use and store it as the default, and it produces a set of images in a consistent style at common sizes. The readable output skill writes notes, retrospectives or tutorials as a structured HTML long form.

There is a self review element throughout. The page design skill asks for high fidelity states and a final package, the backend logic skill asks for a rule table with examples and, where needed, an interaction simulator, and the case radar skill returns a case set with screenshots and sources.

## Where a personal collection stops being reusable

The first limitation is authorship. These are one person's habits, documented in a form that happens to be executable. Where that person works through requirements before touching code, the coding skills will help. Where your team does something else, you are reading a stranger's process, and the value drops to whatever overlaps with your own habits.

The second is that the documentation is Chinese first. The README is written in Simplified Chinese with an English version linked from the top, but the skill content itself is part of the method, and a workflow written in one language may not read naturally to a team working in another. The repository description is also in Chinese, describing the collection as improving development and product management efficiency.

The third is version drift, already noted. With two tags in 2026 and a last push on 2026-10-11, the master branch moves faster than the releases, and nothing in the repository describes which version of a skill you have installed. Copying folders by hand across several machines is how you end up with two people running different workflows and blaming the tool.

The fourth is scope. These skills describe how to organise work, and some of them assume tools you may not have, such as a signed in gh or a Codex subscription. If your environment forbids outbound calls to model providers beyond the one you already pay for, the image and comic skills are dead weight, and the collection offers no guidance on the remaining ones without them.

## Conclusion

Adopt Yunshu SkillsHub if you want one author's hard earned process templates for planning, review and writing rather than a generic prompt collection, and install it selectively with npx skills add so you can see the list before choosing. Do not expect the skills to be self-contained: dual-agent-collaboration needs both Codex and Claude Code on the machine, git-push needs a logged in gh, and the image, comic and PPT skills need Codex CLI with a subscription. Before you install anything, read the thinking and writing skills against your own habits, keep each skill folder intact because the templates and reference files are the point, and check the CHANGELOG.md and the master branch, since the tags only reach v0.1.0 while the last push was on 2026-10-11.

## FAQ

### How do I install the skills from Yunshu SkillsHub into Claude Code?

Use npx skills add yunshu0909/yunshu_skillshub --list to see the skills first, then install the ones you want with the global and agent flags, for example npx skills add yunshu0909/yunshu_skillshub -g -a claude-code codex --skill thinking-partner writing-assistant. You can also copy the skill folders manually into ~/.claude/skills for Claude Code.

### What does a skill folder in Yunshu SkillsHub contain?

Each skill is a directory with a SKILL.md file inside a category folder, and the README asks you to keep the folder complete because the templates, reference files and scripts are part of the method. Copying only the markdown file leaves the skill without the files it refers to.

### Which skills in Yunshu SkillsHub need extra tools?

The dual-agent-collaboration skill needs both Codex and Claude Code installed on the machine, and the git-push skill needs a logged in gh to cut a release. The image rendering, comic making and slide skills use the image generation built into Codex, so they need Codex CLI installed and signed in through a Codex subscription.

### How many skills are in Yunshu SkillsHub and how are they grouped?

The repository advertises 27 skills, arranged in category folders for coding, thinking, learning, writing, visualization, brand and agent. The README also ships an English version of the README alongside the Chinese original.

## Sources

- [Issues](https://github.com/yunshu0909/yunshu_skillshub/issues)
- [License: MIT](https://github.com/yunshu0909/yunshu_skillshub/blob/master/LICENSE)
- [README](https://github.com/yunshu0909/yunshu_skillshub/blob/master/README.md)
- [Releases](https://github.com/yunshu0909/yunshu_skillshub/releases)
- [yunshu0909/yunshu_skillshub on GitHub](https://github.com/yunshu0909/yunshu_skillshub)

---

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