Skip to content
Skills Library
AI & agents · Building & coding

create-skill

/create-skill

Create, validate, and install custom local skills. Use when you need to create a new skill (or update an existing skill) that extends agent capabilities with specialized knowledge, workflows, or tool integrations. Also use when asked to add a reusable capability that should persist across sessions.

Repository
open-duet ↗
Licence
MIT
Last repository change
30.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/init_skill.py, scripts/quick_validate.py

What it does and when to use it

Create, validate, and install custom local skills. Use when you need to create a new skill (or update an existing skill) that extends agent capabilities with specialized knowledge, workflows, or tool integrations. Also use when asked to add a reusable capability that should persist across sessions.

Original author description

Create, validate, and install custom local skills. Use when you need to create a new skill (or update an existing skill) that extends agent capabilities with specialized knowledge, workflows, or tool integrations. Also use when asked to add a reusable capability that should persist across sessions.

How it works

  1. What Skills Provide
  2. Core Principles
  3. Skill Anatomy
  4. Creation Process
  5. Managing Skills
  6. What NOT to Include
Original SKILL.md headings · 155 lines, 844 words
SKILL.md preview
---
name: create-skill
target: both
description: Create, validate, and install custom local skills. Use when you need to create a new skill (or update an existing skill) that extends agent capabilities with specialized knowledge, workflows, or tool integrations. Also use when asked to add a reusable capability that should persist across sessions.
---

# Creating Skills

Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools. They transform a general-purpose agent into a specialist equipped with procedural knowledge no model fully possesses.

## What Skills Provide

1. **Specialized workflows** — multi-step procedures for specific domains
2. **Tool integrations** — instructions for working with APIs or file formats
3. **Domain expertise** — company-specific knowledge, schemas, business logic
4. **Bundled resources** — scripts, references, and assets for repetitive tasks

## Core Principles

**Concise is key.** The context window is shared. Only add what the agent doesn't already know. Prefer concise examples over verbose explanations.

**Set appropriate degrees of freedom:**

- **High freedom** (text instructions): when multiple approaches are valid
- **Medium freedom** (pseudocode/scripts with params): when a preferred pattern exists
- **Low freedom** (exact scripts): when operations are fragile or consistency is critical

**Progressive disclosure.** Skills load in three levels:

1. Metadata (name + description) — always in context (~100 words)
2. SKILL.md body — loaded when skill triggers (<500 lines)
3. Bundled resources — loaded as needed (unlimited)

## Skill Anatomy

```
skill-name/
├── SKILL.md              # Required — entry point with YAML frontmatter
├── scripts/              # Optional — executable code (Python/Bash)
├── references/           # Optional — docs loaded into context as needed
└── assets/               # Optional — templates, images, fonts for output
```

### SKILL.md

- **Frontmatter** (YAML): `name` and `description` are required. Only these two fields determine when the skill triggers — make the description comprehensive about when to use it.
- **Body** (Markdown): Instructions and guidance. Only loaded after triggering.

### Bundled Resources

- **`scripts/`**: Deterministic code that would otherwise be rewritten each time. Token efficient — can be executed without loading into context.
- **`references/`**: Documentation loaded on demand. Keeps SKILL.md lean. For large files (>10k words), include grep patterns in SKILL.md.
- **`assets/`**: Files used in output (templates, images, fonts). Not loaded into context.

**Avoid duplication** between SKILL.md and reference files. Keep only essential workflow instructions in SKILL.md; move detailed reference material to `references/`.

## Creation Process

### Step 1: Understand the Use Cases

Clarify concrete examples of how the skill will be used:

- What triggers it? What would a user say?
- What functionality should it support?
- What's the expected output?

### Step 2: Plan Reusable Contents

For each use case, identify what would help when repeating the workflow:

- Scripts that would otherwise be rewritten each time
- Reference docs (schemas, API docs) that would need rediscovery
- Assets (templates, boilerplate) that stay consistent

### Step 3: Initialize

A skill you write belongs to you: it lives in your own agent folder, syncs, and
travels when you are shared or installed elsewhere. Your `your-folder` system
prompt names the path. Scaffold it there:

```bash
mkdir -p <your folder>/.agents/skills && cd <your folder>/.agents/skills
bunx skills init <skill-name>
```

This creates `<skill-name>/SKILL.md` with a template. Edit it to fill in the
content. For a fuller scaffold with example resource directories:

```bash
python scripts/init_skill.py <skill-name> --path <your folder>/.agents/skills
```

Write a skill for the whole workspace under the drive root's `.agents/skills`
instead — every agent in the workspace loads it — and only when the user asks
for that.

### Step 4: Write the Skill

**Frontmatter rules:**

- `name`: kebab-case, max 64 chars
- `description`: max 1024 chars, no angle brackets. Include ALL "when to use" info here — the body only loads after triggering.

**Body guidelines:**

- Use imperative form
- Keep under 500 lines — split to reference files if longer
- Include exact commands, code snippets, and examples
- Reference bundled files with clear descriptions of when to read them

**Design patterns for content organization:**

- **Multi-step processes**: See `references/workflows.md`
- **Output format/quality standards**: See `references/output-patterns.md`

### Step 5: Validate

Run the validation script to check the skill structure:

```bash
python scripts/quick_validate.py <your folder>/.agents/skills/<skill-name>
```

Checks: frontmatter format, naming conventions, description length, allowed properties.

### Step 6: Verify It Loads

Written in place, the file *is* the installation — there is nothing to
register. Confirm the next session will see it:

```bash
duet skills
```

Report the skill as ready only once it appears there, with `"scope": "project"`
and a path inside your folder. `"scope": "user"` means a machine-level copy,
which neither syncs nor travels with you.

**Never hand-write into `~/.agents/skills` or `~/.claude/skills`.** Those are
managed link farms and edits there are repaired away. A skill that genuinely
belongs to the machine rather than to you is installed with
`bunx skills add <path> -g -y`, and only when the user asks for that.

### Step 7: Iterate

Use the skill on real tasks, notice struggles, update SKILL.md or resources, and test again.

## Managing Skills

```bash
duet skills                       # What this session actually loads, with paths
bunx skills remove <name> -y      # Remove one from the folder you run it in
```

Deleting the skill's folder removes a hand-written one.

## What NOT to Include

Do not create extraneous files: README.md, INSTALLATION_GUIDE.md, CHANGELOG.md, etc. A skill should only contain what the agent needs to do the job.
Files in this package (5)
  • SKILL.md 6 KB
  • references/output-patterns.md 2 KB
  • references/workflows.md 1 KB
  • scripts/init_skill.py 11 KB
  • scripts/quick_validate.py 3 KB

Versions

RepositoryScoreLicence
This page · aomni-com/open-duet100MIT
mgiovani/cc-arsenal100MIT
zylos-ai/zylos-core100MIT
mthines/agent-skills100MIT
jongio/skills100MIT
fairladyz625/harness-anything100AGPL-3.0
coco-research/coco100MIT
builderio/agent-native100MIT
BrandeisPatrick/silo-harness100MIT

Database snapshot: 13.11.2026 · package version f9e2c4b7149d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100skill-creator
    Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends the agent's capabilities with specialized knowledge, workflows, or tool integrations.
  • 90skill-creator
    Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Codex's capabilities with specialized knowledge, workflows, or tool integrations.
  • 100skill-creator
    Guide for creating effective skills. Use when creating a new skill (or updating an existing skill) that extends an agent’s capabilities with specialized knowledge, workflows, or tool integrations.
  • 100skill-creator
    Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
  • 100skill-creator
    Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
  • 100skill-creator
    Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.