技能创建助手

Files (17)

• LICENSE.txt
• SKILL.md
• analyzer.md · agents/
• comparator.md · agents/
• grader.md · agents/
• generate_review.py · eval-viewer/
• viewer.html · eval-viewer/
• schemas.md · references/
• __init__.py · scripts/
• aggregate_benchmark.py · scripts/
• generate_report.py · scripts/
• improve_description.py · scripts/
• init_skill.py · scripts/
• package_skill.py · scripts/
• run_eval.py · scripts/
• run_loop.py · scripts/
• utils.py · scripts/

SKILL.md (first lines)

# Skill Creator

Create and iteratively improve skills through evaluation, scoring, and description optimization.

## About Skills

Skills are modular, self-contained packages that extend Claude's capabilities with specialized knowledge, workflows, and tools. They transform Claude from a general-purpose agent into a specialized one equipped with procedural knowledge.

### 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

## Core Principles

### Concise is Key

The context window is a public good shared with system prompt, conversation history, other skills' metadata, and the user request.

**Default assumption: Claude is already very smart.** Only add context Claude doesn't already have. Challenge each piece of information: "Does Claude really need this?" and "Does this paragraph justify its token cost?"

### Set Appropriate Degrees of Freedom

- **High freedom** (text-based instructions): Multiple approaches valid, decisions depend on context
- **Medium freedom** (pseudocode/scripts with parameters): Preferred pattern exists, some variation acceptable
- **Low freedom** (specific scripts, few parameters): Operations fragile, consistency critical

### Anatomy of a Skill

```
skill-name/
├── SKILL.md (required)
│   ├── YAML frontmatter (name + description required)
│   └── Markdown instructions
└── Bundled Resources (optional)
    ├── scripts/      — Executable code
    ├── references/   — Documentation loaded into context as needed
    └── assets/       — Files used in output (templates, icons, fonts)
```

#### SKILL.md (required)

- **Frontmatter** (YAML): `name` and `description` fields. These determine when the skill triggers — be clear and comprehensive.
- **Body** (Markdown): Instructions loaded AFTER the skill triggers.

#### Bundled Resources (optional)

- **scripts/**: Executable code for tasks needing deterministic reliability or repeatedly rewritten code
- **references/**: Documentation loaded as needed to inform Claude's process
- **assets/**: Files used in output, not loaded into context

#### What to Not Include

Do NOT create extraneous documentation: README.md, INSTALLATION_GUIDE.md, CHANGELOG.md, etc. The skill should only contain information needed for an AI agent to do the job.

## Communicating with the User

Many skill users are not technical. When communicating:

- Use plain language. Avoid jargon unless the user introduced it first.
- Explain what you're doing and why, not just the technical details.
- When asking for input, provide concrete examples of what you need.
- If something fails, explain what happened in user-friendly terms and what you'll try next.
- Celebrate progress — let the user know when milestones are reached.

## Skill Creation Process

1. Understand the skill with concrete examples
2. Plan reusable skill contents (scripts, references, assets)
3. Initialize the skill (run init_skill.py)
4. Edit the skill (implement resources and write SKILL.md)
5. Package the skill (run package_skill.py)
6. Run and evaluate test cases
7. Improve the skill description
8. Iterate based on evaluation results

### Step 1: Understanding the Skill

Skip only when usage patterns are already clearly understood.

Ask targeted questions:
- "What functionality should this skill support?"
- "Can you give examples of how it would be used?"
- "What would a user say that should trigger this skill?"

Avoid overwhelming users — start with the most important questions.

### Step 2: Planning Reusable Contents

Analyze each concrete example:
1. Consider how to execute from scratch
2. Identify what scripts, references, and assets would help when executing repeatedly

### Step 3: Initializing the Skill

Run `init_skill.py` to generate a template skill directory:

```bash
scripts/init_skill.py <skill-name> --path <output-directory>
```

Skip if the skill already exists and only needs iteration.

### Step 4: Edit the Skill

Remember: the skill is for another Claude instance to use. Include non-obvious procedural knowledge and domain-specific details.

#### Frontmatter

Write `name` and `description`:
- `description` is the primary triggering mechanism
- Include both what the skill does AND specific triggers/contexts
- All "when to use" info goes here — the body is only loaded after triggering

For LaborAny skills, also include `icon` and `category`.

#### Body

From laborany/laborany, MIT.

More from laborany/laborany