create-skill

Files (1)

• SKILL.md

SKILL.md (first lines)

Build a new Claude Code skill from the user's description. Handles the full lifecycle: scaffold, test, fix, validate, report.

Skill description: $ARGUMENTS

## Overview

You are a meta-skill that autonomously creates new Claude Code skills. You will:
1. Parse the user's description to determine skill type and requirements
2. Create the skill file with proper structure
3. Generate a pytest test suite
4. Run tests, fix failures (up to 3 iterations)
5. Validate the skill is loadable
6. Generate a validation report
7. Present the finished skill only after all checks pass

## Step 1: Parse the Description

Analyze `$ARGUMENTS` to determine:

- **Skill name**: derive a short kebab-case slug (e.g., "budget-report", "meeting-notes")
- **Skill type**: determine if this should be a full skill (`~/.claude/skills/<name>/SKILL.md`) or a simple command (`~/.claude/commands/<name>.md`). Use a skill for anything with embedded Python, agent teams, or complex logic. Use a command for simple prompt-based workflows (like research templates).
- **Output format**: what does the skill produce? (.docx, .xlsx, .pptx, .md, .pdf, .csv, or text output)
- **Key behaviors**: what specific actions, transformations, or analyses does it perform?
- **Input requirements**: what arguments does it need?
- **Edge cases**: empty input, missing directories, missing files, invalid arguments

If the description is too vague to build a working skill, use AskUserQuestion to clarify before proceeding. Otherwise, make reasonable assumptions and note them.

## Step 2: Create the Team

```
TeamCreate with team_name: "create-skill-<name>"
```

Create 4 tasks:
1. **Build the skill file** (builder agent)
2. **Write the test suite** (tester agent)
3. **Run tests and iterate** (coordinator — you)
4. **Generate validation report** (coordinator — you)

Set task 3 as blocked by tasks 1 and 2. Set task 4 as blocked by task 3.

## Step 3: Spawn the Builder Agent

Spawn a `general-purpose` agent named `builder` with `team_name` set. Give it these instructions:

### Builder Agent Instructions

Create a Claude Code skill at the determined path. Follow these patterns exactly:

**For skills (`~/.claude/skills/<name>/SKILL.md`):**

```yaml
---
name: <slug>
description: <one-line description>
argument-hint: "<usage hint>"
---
```

Followed by the full implementation. Reference these conventions from existing skills:

- Use `$ARGUMENTS` for the full argument string
- For Python-based skills: embed the complete Python code in the SKILL.md as fenced code blocks, with instructions to write to `/tmp/` and execute via Bash
- For document-producing skills: include the full python-docx/openpyxl/python-pptx code inline
- Steps should be numbered and explicit
- Include a "Rules" section at the end with constraints
- Author metadata: "$AUTHOR_NAME" where applicable
- Output paths: `~/Documents/` or `~/Downloads/` depending on type
- Always clean up temp files after execution
- Always open the output file with `open` command at the end
- Always print a summary report of what was created

**For commands (`~/.claude/commands/<name>.md`):**

```markdown
# Title: $ARGUMENTS

Instructions here...
```

No YAML frontmatter. Plain markdown with instructions.

**Critical rules for the builder:**
- Study the existing skills at `~/.claude/skills/` to match the style and conventions
- If the skill produces .docx files, use the python-docx + lxml comment insertion pattern from doc-review, NOT raw zipfile manipulation (unless inserting comments into existing docs, which needs the 3-file XML approach for Word 2016+ compatibility)
- If the skill produces .xlsx files, use openpyxl with proper styling (reference time-savings skill)
- If the skill produces .pptx files, use the full helper function set from the pptx skill
- Make the skill fully self-contained — no imports from custom modules
- Test the embedded Python by running it mentally for syntax correctness
- Include error handling for: file not found, missing directories (create them), invalid input

After creating the file, send the file path and a brief summary back to the coordinator.

## Step 4: Spawn the Tester Agent

Spawn a `general-purpose` agent named `tester` with `team_name` set. Give it these instructions:

### Tester Agent Instructions

Create a pytest test suite at `/tmp/test_skill_<name>.py` that validates the skill. The test suite must cover:

**1. File creation test:**
```python
def test_skill_file_exists():
    """Verify the skill file was created at the correct path."""
    assert os.path.exists(SKILL_PATH)
```

**2. Syntax validation test:**
```python
def test_skill_syntax():
    """Verify YAML frontmatter parses correctly (for skills) or markdown is valid (for commands)."""
```
- For skills: parse the YAML frontmatter, verify `name` and `description` fields exist
- For commands: verify the file starts with `# ` and contains `$ARGUMENTS`

**3. Output format tests (based on what the skill produces):**

From jasonbhorne/claude-code-skills, MIT.

More from jasonbhorne/claude-code-skills