skill-creator

# Skill Creator

This skill provides guidance for creating effective skills.

## About Skills

Skills are modular, self-contained packages that extend Claude's capabilities by providing
specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific
domains or tasks—they transform Claude from a general-purpose agent into a specialized agent
equipped with procedural knowledge that no model can fully possess.

**IMPORTANT:**
- Skills are not documentation, they are practical instructions for Claude Code to use the tools, packages, plugins or APIs to achieve the tasks.
- Each skill teaches Claude how to perform a specific development task, not what a tool does.
- Claude Code can activate multiple skills automatically to achieve the user's request.

### What Skills Provide

1. Specialized workflows - Multi-step procedures for specific domains
2. Tool integrations - Instructions for working with specific file formats or APIs
3. Domain expertise - Company-specific knowledge, schemas, business logic
4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks

### Anatomy of a Skill

Every skill consists of a required SKILL.md file and optional bundled resources:

```
.claude/skills/
└── skill-name/
    ├── SKILL.md (required)
    │   ├── YAML frontmatter metadata (required)
    │   │   ├── name: (required)
    │   │   ├── description: (required)
    │   │   ├── license: (optional)
    │   │   └── version: (optional)
    │   └── Markdown instructions (required)
    └── Bundled Resources (optional)
        ├── scripts/          - Executable code (Python/Bash/etc.)
        ├── references/       - Documentation intended to be loaded into context as needed
        └── assets/           - Files used in output (templates, icons, fonts, etc.)
```

#### Requirements (**IMPORTANT**)

- Skill should be combined into specific topics, for example: `cloudflare`, `cloudflare-r2`, `cloudflare-workers`, `docker`, `gcloud` should be combined into `devops`
- `SKILL.md` should be **less than 150 lines** and include the references of related markdown files and scripts.
- Each script or referenced markdown file should be also **less than 150 lines**, remember that you can always split them into multiple files (**progressive disclosure** principle).
- Descriptions in metadata of `SKILL.md` files should be both concise (**less than 200 characters**) and still contains enough usecases of the references and scripts, this will help skills can be activated automatically during the implementation process of Claude Code.
- **Referenced markdowns**:
  - Sacrifice grammar for the sake of concision when writing these files.
  - Can reference other markdown files or scripts as well.
- **Referenced scripts**:
  - Prefer nodejs or python scripts instead of bash script, because bash scripts are not well-supported on Windows.
  - If you're going to write python scripts, make sure you have `requirements.txt`
  - Make sure scripts respect `.env` file follow this order: `process.env` > `$HOME/.claude/skills/${SKILL}/.env` (global) > `$HOME/.claude/skills/.env` (global) > `$HOME/.claude/.env` (global) > `./.claude/skills/${SKILL}/.env` (cwd) > `./.claude/skills/.env` (cwd) > `./.claude/.env` (cwd)
  - Create `.env.example` files to show the required environment variables.
  - Always write tests for these scripts.

**IMPORTANT:**
- Always keep in mind that `SKILL.md` and reference files should be token consumption efficient, so that **progressive disclosure** can be leveraged at best.
- `SKILL.md` should be **less than 150 lines**
- Referenced markdown files should be also **less than 150 lines**, remember that you can always split them into multiple files (**progressive disclosure** principle).
- Referenced scripts: no limit on length, just make sure it works, no compile issues, no runtime issues, no dependencies issues, no environment issues, no platform issues.

**Why?**
Better **context engineering**: leverage **progressive disclosure** technique of Agent Skills, when agent skills are activated, Claude Code will consider to load only relevant files into the context, instead of reading all long `SKILL.md` as before.

#### SKILL.md (required)

**File name:** `SKILL.md` (uppercase)
**File size:** Under 150 lines, if you need more, split it to multiple files (<150 lines each) in `references` folder.
`SKILL.md` is always short and concise, straight to the point, treat it as a quick reference guide.

**Metadata Quality:** The `name` and `description` (**MUST be under 200 characters**) in YAML frontmatter determine when Claude will use the skill. Be specific about what the skill does and when to use it, DO NOT sound generic, vague or educational. Use the third-person (e.g. "This skill should be used when..." instead of "Use this skill when...").

#### Bundled Resources (optional)

##### Scripts (`scripts/`)

Executable code (Python/Bash/etc.) for tasks that require deterministic reliability or are repeatedly rewritten.

- **When to include**: When the same code is being rewritten repeatedly or deterministic reliability is needed
- **Example**: `scripts/rotate_pdf.py` for PDF rotation tasks
- **Benefits**: Token efficient, deterministic, may be executed without loading into context
- **Note**: Scripts may still need to be read by Claude for patching or environment-specific adjustments

**IMPORTANT:**
- Write tests for scripts.
- Run tests and make sure it works, if tests fail, fix them and run tests again, repeat until tests pass.
- Run scripts manually with some usecases to make sure it works.
- Make sure scripts respect `.env` file follow this order: `process.env` > `$HOME/.claude/skills/${SKILL}/.env` (global) > `$HOME/.claude/skills/.env` (global) > `$HOME/.claude/.env` (global) > `./.claude/skills/${SKILL}/.env` (cwd) > `./.claude/skills/.env` (cwd) > `./.claude/.env` (cwd)

##### References (`references/`)

Documentation and reference material intended to be loaded as needed