Skip to main content
ClaudeWave
Skill311 estrellas del repoactualizado 1mo ago

my-skill

# my-skill This template defines the structure and configuration options for creating a Claude Code skill, which are reusable task modules that extend Claude's capabilities with custom instructions and tool permissions. Use this when building specialized skills for Claude to auto-load based on user queries, with optional features like isolated execution contexts, model overrides, and tool access controls.

Instalar en Claude Code
Copiar
git clone --depth 1 https://github.com/LukeRenton/explore-claude-code /tmp/my-skill && cp -r /tmp/my-skill/site/content/.claude/skills/my-skill ~/.claude/skills/my-skill
Después abre una sesión nueva de Claude Code; el skill carga automáticamente.

SKILL.md

These two fields are the only ones required. `name` must be lowercase with hyphens, max 64 characters, and match the parent directory name. `description` is what Claude reads at startup to decide when the skill is relevant (max 1024 characters).

## Optional Frontmatter Fields

Add any of these to the `---` block above to customise behaviour:

| Field | Example | Purpose |
|---|---|---|
| `argument-hint` | `[issue-number]` | Hint shown during autocomplete to indicate expected arguments |
| `disable-model-invocation` | `true` | Prevent Claude from auto-loading. User must type `/name` explicitly. Use for deploys, sends, destructive ops |
| `user-invocable` | `false` | Hide from the `/` menu. Claude can still load it automatically. Use for background knowledge |
| `allowed-tools` | `Read, Grep, Bash(npm *)` | Tools Claude can use without asking permission. Space-delimited, supports patterns |
| `model` | `claude-sonnet-4-6` | Override the model when this skill is active. Useful for cost control |
| `context` | `fork` | Run in an [isolated subagent](^A separate Claude instance with its own context. The skill content becomes the subagent's system prompt). Skill content becomes the subagent's prompt |
| `agent` | `Explore` | Which subagent runs when `context: fork`. Built-in: `Explore`, `Plan`, `general-purpose`, or custom from `.claude/agents/` |
| `license` | `Apache-2.0` | License name or reference to a bundled LICENSE file |
| `compatibility` | `Requires git, docker` | Environment requirements (max 500 chars) |
| `metadata` | key-value pairs | Arbitrary metadata (author, version, etc.) |

---

# Body Content

Everything below the frontmatter is the instruction body. Claude reads this when the skill is activated. Write whatever helps Claude perform the task. There are no format restrictions.

Good body content includes:

- Step-by-step instructions for the task
- Examples of inputs and expected outputs
- Common edge cases and how to handle them
- References to supporting files in this skill folder

## String Substitutions

[Placeholders](^Variables in your SKILL.md that get replaced with real values before Claude sees the content) are replaced with real values before Claude sees the content:

| Placeholder | Resolves To |
|---|---|
| `$ARGUMENTS` | Everything the user typed after the skill name |
| `$ARGUMENTS[N]` or `$N` | A specific argument by index (0-based) |
| `${CLAUDE_SESSION_ID}` | The current session ID |
| `${CLAUDE_SKILL_DIR}` | Path to this skill's directory |

Example: `/my-skill SearchBar React Vue` gives `$0` = "SearchBar", `$1` = "React", `$2` = "Vue".

If `$ARGUMENTS` is not present in the content, arguments are appended as `ARGUMENTS: <value>`.

## Dynamic Context Injection

The `!` backtick syntax runs shell commands before the content reaches Claude. Output replaces the placeholder:

- PR diff: `` !`gh pr diff` ``
- Dependencies: `` !`cat package.json | jq .dependencies` ``
- Changed files: `` !`git diff --name-only` ``

This is [preprocessing](^The commands run at skill load time, not during conversation. Claude only sees the final output, not the commands themselves). Claude only sees the final output, not the commands.

---

# Supporting Files

Keep SKILL.md under 500 lines. Move detailed material to separate files and reference them from the body:

- [references/REFERENCE.md](references/REFERENCE.md): Detailed documentation loaded on demand
- [assets/template.md](assets/template.md): Templates and static resources
- [scripts/helper.sh](scripts/helper.sh): Executable code Claude can run

Use relative paths from SKILL.md. Keep references one level deep. Navigate into these folders to learn more about each.
core-plannerSubagent

Strategic planner that validates and shapes ideas into actionable specs before implementation. Use when a brainstorm or feature idea needs to be pressure-tested, scoped, and turned into a clear specification with success criteria and UATs. Sits between brainstorming and technical planning.

build-agentSkill

Builds new Claude Code agents with consistent structure, enforced standards, and project-aware configuration. Use when creating a new agent, when the user describes a specialised role they want delegated to, or when discussing team composition.

build-skillSkill

Builds new Claude Code skills with consistent structure, enforced standards, and project-aware configuration. Use when creating a new skill, when the user describes a workflow they want automated, or when the user says they want a new slash command.

core-brainstormSkill

Collaborative brainstorming mode for thinking through problems, ideas, and features before planning. Use when the user wants to discuss, explore ideas, or think through a problem without writing code.

frontend-designSkill

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

core-backendSubagent

Backend implementation specialist. Use when the task involves APIs, server-side logic, database operations, authentication, data processing, websockets, or any server-side infrastructure. Focuses on robustness, simplicity, and self-audited correctness.

core-frontendSubagent

Frontend implementation specialist. Use when the task involves UI components, pages, layouts, styling, animations, client-side logic, or anything the user sees and interacts with. Focuses on UX quality, accessibility, and cross-device reliability.

core-orchestratorSubagent

Central coordinator that decomposes tasks, delegates to specialist agents, manages feedback loops between implementers and reviewers, and ensures all agents are satisfied before returning control. Use when a task spans multiple agents, requires coordination between specialists, or when the user wants hands-off execution of a planned feature.