Skills
The skills catalog — how skills load, when each one triggers, and how to author your own.
A skill is packaged expertise: a folder under .claude/skills/ whose entry
point, SKILL.md, carries a short frontmatter header and a procedural or
reference body. When a skill is invoked, the agent reads that body and becomes
momentarily competent at the procedure it describes — commit discipline, a
research method, a whole animation library's determinism rules. The install
ships 23 skills; the flat list lives in Catalogs,
and this page explains how they work, what each group is for, and how you add
your own.
Two properties make skills the platform's most dynamic layer:
- The model can reach for them itself. Every skill's
descriptionstates what it does and when to use it. An agent whose current work matches a description pulls that skill in on its own — no dispatch, no configuration. - The file is the deployment.
SKILL.mdis read fresh at the moment of invocation. Edit it, save, and the next invocation uses the new version — no restart, no rebuild.
How a skill triggers
Frontmatter sets one of three invocation postures:
| Posture | How it fires | Marked by |
|---|---|---|
| Auto-invocable | The agent matches its current work against the description and loads the skill itself; also callable as /name | The default — no flag |
| Manual only | Fires only when you type /name; an agent never auto-fires it | disable-model-invocation: true — used for side-effecting or expensive skills (a commit, a long deep-dive) |
| User-invocable | Surfaced explicitly as an operator slash command | user-invocable: true |
Two optional modifiers refine a posture. argument-hint documents what to
pass after the slash command — /deepdive [subject] [intended consumer] reads
its two arguments straight from the hint's positions. allowed-tools
restricts what the skill may touch while it runs: the commit skill, for
example, is limited to git commands and read-only file access. One skill in
the set also runs forked — deep-research executes inside an isolated
sub-agent so a long investigation never floods the calling session's context.
Only each skill's name and description sit in an agent's context by default; the body — and any sibling reference files — load on demand at invocation. That is why a library this size costs an agent almost nothing until the moment a skill is actually used, and why adding more skills stays cheap.
Research & analysis
| Skill | Trigger | What it does |
|---|---|---|
deepdive | Manual — /deepdive [subject] [intended consumer] | Produces a verbose, primary-source deep-dive on any subject, shaped for a named downstream consumer. The heavyweight, deliberate research surface — companion to the deepdive-author agent |
deep-research | Auto, forked | Deep investigation inside a codebase — trace data flows, understand architecture. Runs in an isolated sub-agent and returns conclusions, not file dumps |
Invoking /deepdive looks like handing over a commission: the skill's body is
a full method — scoping, consumer-first framing, parallel research, a fixed
output skeleton — and the session follows it to a finished document.
deep-research you mostly never invoke: agents reach for it themselves
whenever a question requires sweeping many files.
Authoring & design
| Skill | Trigger | What it does |
|---|---|---|
skill-builder | Manual — /skill-builder [name or description] | Interviews you and builds a complete new skill — posture, structure, guardrails, reference files. The authoring authority for the format itself |
command-center-design | User-invocable | The design-system enforcer — tokens, type, iconography, voice, and a clickable UI kit — for producing on-brand interfaces and assets. A reference skill: its entry file routes the agent to sibling files loaded as needed |
frontend-feature | Manual — /frontend-feature [feature-name] | Scaffolds a new frontend feature module following the patterns it discovers in the project — nothing hardcoded |
commit | Manual — /commit [message hint] | Conventional-commit authoring: analyze the diff, draft the message, stage deliberately, commit. Tool-restricted to git and read-only access |
codebase-viz | Manual — /codebase-viz | Generates an interactive HTML visualization of a repository's structure from a bundled script |
The manual posture across this group is deliberate: anything that commits, scaffolds, or spends significant time fires only when you ask for it.
Animation adapters
Eight reference skills, one per animation technology, each teaching an agent how to make that library render-deterministic inside the HyperFrames video engine — animations that seek to any frame identically during preview and final render:
| Skill | Covers |
|---|---|
gsap | GSAP tweens, easing, stagger, and timeline composition |
three | Three.js and WebGL scenes, animation mixers, camera motion, shaders |
lottie | Lottie and dotLottie embeds — deterministic After Effects exports |
animejs | Anime.js animations and timelines, registered for seek control |
css-animations | CSS keyframes and timing made seekable |
waapi | The Web Animations API — element.animate(), precise time control |
typegpu | TypeGPU and raw WebGPU — shaders, compute, particle systems |
tailwind | Tailwind v4 browser-runtime patterns inside compositions |
All eight are auto-invocable: when an agent writes GSAP code it loads the
GSAP adapter, and so on. Their descriptions are written as routers — each
one states when to use it and when a sibling fits better, so related skills
do not fire on the same work. The hyperframes-html-author pipeline agent is
the heaviest consumer: it invokes whichever adapters its storyboard's beats
require, at runtime.
Video workflow
The skills behind the video and footage features:
| Skill | Trigger | What it does |
|---|---|---|
hyperframes | Auto | The master authoring skill — compositions, captions, voiceover, audio-reactive visuals, transitions; a large multi-file skill whose entry point routes to pattern and style references |
hyperframes-cli | Auto | The dev loop — scaffold, lint, inspect, preview, render, environment troubleshooting |
hyperframes-media | Auto | Asset preprocessing — local text-to-speech, transcription, background removal; each model downloads on first use |
hyperframes-registry | Auto | Installing and wiring registry blocks and components into a composition |
contribute-catalog | Auto | Authoring a new registry block and shipping it upstream as a contribution — explicitly routed away from everyday authoring |
website-to-hyperframes | Auto | Capture a website and build a video from it — the paste-a-URL-get-a-promo path |
remotion-to-hyperframes | Auto | Port an existing Remotion composition to HyperFrames — fires only on an explicit migration request, and detects patterns that will not translate |
footage-prep | Auto | Edit raw footage into a clean, condensed cut — fillers, retakes, silence, grading, captions — driving the footage tools end to end |
Authoring your own
Adding a skill is the cheapest way to extend what your agents can do — three surfaces, all hot:
/skill-builder— the in-conversation route. It interviews you (goal, trigger, posture, workflow, guardrails), then writes the folder, the frontmatter, and the body to its own standard.- The Skills view — the no-AI route. The New and Clone dialogs scaffold the folder and validate the frontmatter; the three-pane editor lets you write and revise every file in place. Saving is deploying.
- By hand — create
.claude/skills/<name>/SKILL.mdin any editor. The directory existing is the registration.
Conventions that make a skill good, drawn from the shipped set:
- Invest in the description. It is the load gate — write it as what this does plus when to use it, with the words an agent would naturally produce. In a family of related skills, say when a sibling applies instead.
- Manual posture for side effects. Anything that commits, sends, deploys,
or spends should carry
disable-model-invocation: true. - Keep the entry file lean. Move bulk into sibling files — references, examples, templates, scripts — and tell the agent when to load each. The shipped design skill is the pattern to copy.
- Least-privilege risky skills with
allowed-tools. - Always include a rules block. Explicit constraints in the body are what keep a skill's behavior stable across models and months.
Skills next to the other layers
| Layer | It is | Loaded |
|---|---|---|
| Skill | A procedure or reference body the agent itself reaches for | On match or /name, hot |
| Agent | A dispatchable specialist with a contract | Per spawn, hot |
| Doctrine | House rules every relevant agent carries | Per read, hot |
| MCP server | A typed tool endpoint (code) | At server start |
The distinguishing fact: a skill is the only layer the agent decides to load mid-task by matching its own work against a description. When you codify a body of craft, that is the decision to make — a skill if agents should reach for it situationally, a protocol if they should always carry it.