What does this skill do, and when should you use it?
skill-creator is a built-in meta-skill from the DeepTutor repository: it performs no task itself, but supplies a complete authoring methodology when a user wants to create a new skill, improve an existing one, or understand how skills work. It defines the standard skill anatomy (a SKILL.md plus optional references/ directory), the YAML frontmatter schema, and five core principles — the description is the trigger, concise is key, match freedom to fragility, progressive disclosure, and no auxiliary files. It also walks a five-step writing workflow from collecting real usage examples to iterating after real use. The skill is pure guidance text with no scripts and no runtime dependencies.
When loaded, it guides the model to: collect trigger phrases and expected behaviors as concrete examples; identify knowledge that gets re-derived every time and belongs in the skill; draft a SKILL.md with the frontmatter schema (name, description, tags, always, requires); split long examples and schemas into references/ files fetched on demand via read_skill; create the skill through the skill management UI (Space → Skills) or the skills API; then tighten what the model stumbled on after real-world use. It explicitly distinguishes skills from behavior/voice personas, which are managed separately.
- A DeepTutor user who wants to turn an internal team process (a review checklist, a reporting format) into a reusable skill
- An author whose existing skill rarely fires and needs the 'description is the trigger' principle to rewrite its description
- A maintainer with an oversized skill body crowding the context window, learning to use references/ for progressive disclosure
- A developer who wants to understand how DeepTutor loads skill content on demand via the read_skill tool
- A contributor preparing to publish a teaching skill to the EduHub community who needs the format conventions first
How do you install this skill?
- This review is a static source read only; nothing was executed and confidence is low.
- The skill is deeply bound to the DeepTutor ecosystem (read_skill tool, skills management UI/API) and cannot be applied directly in other agent frameworks.
- The skill itself carries no version or changelog, so its independent evolution is untrackable; follow repository-level releases for updates.
- Publisher is not verified by the FollowSkills registry and is treated as unknown — not a deduction, but users should be aware.
The skill ships built into the DeepTutor repository at deeptutor/skills/builtin/skill-creator/SKILL.md — no separate install. To get DeepTutor itself: pip install -U deeptutor, or git clone https://github.com/HKUDS/DeepTutor.git then pip install -e . from source. The source does not document how to copy a single built-in skill into other Agent Skills clients; copying the SKILL.md file manually is implied but unstated.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/HKUDS/DeepTutor.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/deeptutor/skills/builtin/skill-creator" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- Write a DeepTutor skill for our code review checklist
- Why does my skill never trigger?
In DeepTutor, the skill fires automatically when a conversation touches creating or improving skills, per its description. You can also ask directly: "Write a DeepTutor skill for our code review checklist" or "Why does my skill never trigger?". To actually create a skill, use the Space → Skills management UI or the skills API; CLI users manage skills via the deeptutor skill command family.
What are this skill's strengths and limitations?
- Pure guidance text with zero runtime dependencies — any Agent Skills-compatible client can load it
- Five core principles (description-as-trigger, progressive disclosure, etc.) are broadly transferable design lessons
- A complete five-step workflow closes the loop from example collection to post-use iteration
- Clearly separates skills from personas, preventing a common conceptual mix-up
- Step 4 of the workflow (creation) points at DeepTutor-specific UI (Space → Skills) and the skills API, which do not exist outside DeepTutor
- read_skill and friends are DeepTutor runtime mechanics; other clients must substitute their own loading mechanisms
- Guidance only — no scripts or automated validation, so output quality depends entirely on the model executing it
- The source offers no evaluation or test evidence that following the principles measurably improves skill quality
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| DeepTutor Skill Creator this page | 57 · Use with care | ★ 41k | 17d ago | Apache-2.0 |
| Skill Creator | 70 · Strongly recommended | ★ 2.2k | 12d ago | MIT |
| Create New Skills (Meta-Skill) | 62 · Recommended | ★ 1.5k | 8mo ago | — |
| Skill Creator | 48 · Use with care | ★ 3.1k | 8mo ago | MIT |
| Test-Driven Skill Authoring | 44 · Not recommended | ★ 299k | 15d ago | MIT |
DeepTutor's skill system deliberately adopts and stays compatible with the open Agent-Skills format shared with the ClawHub community; this skill teaches authoring for that generic format. Its value over hand-writing a SKILL.md from scratch is that it structures the common failure points — trigger design, progressive disclosure, frontmatter hygiene.
How did FollowSkills review this skill?
Pure guidance document for authoring SKILL.md packages: no scripts, external calls, or standing permissions; least privilege is inherently satisfied. The requires gating (bins/env/sandbox) and read_skill reference show permission awareness. Deductions: no confirmation/rollback narrative (though not needed here), unverified publisher, data-flow disclosure limited to architecture level.
Internally self-consistent: frontmatter schema, principles, and workflow align; trigger test, progressive disclosure, and line cap are explicit and followable; no dependencies means no availability risk. Deductions: no executable paths, no example outputs, no failure-feedback mechanism; static review caps this at 10.
Description precisely states what it does and when it triggers (create/improve skills, explain skill mechanics) and explicitly excludes persona presets; English-only but no network dependency, usable in Chinese environments. Deductions: input/output forms and further non-fit ranges undeclared; bound to the DeepTutor ecosystem (UI/API), cross-ecosystem applicability unstated.
Well-structured with good progressive disclosure; repository-level Apache-2.0 license and active release cadence with CI workflows. Deductions: the skill itself forbids README/changelog ('No auxiliary files'), so no skill-level versioning, changelog, or known-limitations disclosure; maintenance responsibility inferable only at repository level.
As authoring guidance the content is concrete (trigger test, ~500-line cap, example-collection workflow) and offers marginal value to the target user. Deductions: no representative outputs of skills produced via this guidance are verified; comparative benefit over generic prompting is claimed but unevidenced; static cap 7, scoring 6.
Claims trace to the source files themselves with a clean fact/inference boundary. Deductions: no third-party execution evidence, no committed tests covering this skill's key paths (repo tests target mastery_path etc.), no multi-source corroboration; scored 4, below the static cap of 5.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →