playbooks

home / skills / zpankz / mcp-skillset / create-skill

create-skill skill

/create-skill

This skill guides you through creating, updating, and structuring new skills for Kai's AI framework, ensuring clear triggers and proper documentation.

This is most likely a fork of the create-skill skill from danielmiessler
npx playbooks add skill zpankz/mcp-skillset --skill create-skill

Review the files below or copy the command above to add this skill to your agents.

Files (9)
SKILL.md
4.3 KB
---
name: create-skill
description: Guide for creating new skills in Kai's personal AI infrastructure. Use when user wants to create, update, or structure a new skill that extends capabilities with specialized knowledge, workflows, or tool integrations. Follows both Anthropic skill standards and PAI-specific patterns.
---

# Create Skill - Skill Creation Framework

## When to Activate This Skill
- "Create a new skill for X"
- "Build a skill that does Y"
- "Add a skill for Z"
- "Update/improve existing skill"
- "Structure a skill properly"
- User wants to extend Kai's capabilities

## Core Skill Creation Workflow

### Step 1: Understand the Purpose
Ask these questions:
- **What does this skill do?** (Clear, specific purpose)
- **When should it activate?** (Trigger conditions)
- **What tools/commands does it use?** (Dependencies)
- **Is it simple or complex?** (Determines structure)

### Step 2: Choose Skill Type

**Simple Skill** (SKILL.md only):
- Single focused capability
- Minimal dependencies
- Quick reference suffices
- Examples: fabric-patterns, youtube-extraction

**Complex Skill** (SKILL.md + CLAUDE.md + supporting files):
- Multi-step workflows
- Extensive context needed
- Multiple sub-components
- Examples: development, website, consulting

### Step 3: Create Directory Structure

```bash
# Simple skill
${PAI_DIR}/skills/[skill-name]/
└── SKILL.md

# Complex skill
${PAI_DIR}/skills/[skill-name]/
├── SKILL.md           # Quick reference
├── CLAUDE.md          # Full context
└── [subdirectories]/  # Supporting resources
```

### Step 4: Write SKILL.md (Required)

Use this structure:
```markdown
---
name: skill-name
description: Clear description of what skill does and when to use it. Should match activation triggers.
---

# Skill Name

## When to Activate This Skill
- Trigger condition 1
- Trigger condition 2
- User phrase examples

## [Main Content Sections]
- Core workflow
- Key commands
- Examples
- Best practices

## Supplementary Resources
For detailed context: `read ${PAI_DIR}/skills/[skill-name]/CLAUDE.md`
```

### Step 5: Write CLAUDE.md (If Complex)

Include:
- Comprehensive methodology
- Detailed workflows
- Component documentation
- Advanced usage patterns
- Integration instructions
- Troubleshooting guides

### Step 6: Add to Global Context

Update `${PAI_DIR}/global/KAI.md` available_skills section to include the new skill so it shows up in the system prompt.

### Step 7: Test the Skill

1. Trigger it with natural language
2. Verify it loads correctly
3. Check all references work
4. Validate against examples

## Skill Naming Conventions

- **Lowercase with hyphens**: `create-skill`, `web-scraping`
- **Descriptive, not generic**: `fabric-patterns` not `text-processing`
- **Action or domain focused**: `ai-image-generation`, `chrome-devtools`

## Description Best Practices

Your description should:
- Clearly state what the skill does
- Include trigger phrases (e.g., "USE WHEN user says...")
- Mention key tools/methods used
- Be concise but complete (1-3 sentences)

**Good examples:**
- "Multi-source comprehensive research using perplexity-researcher, claude-researcher, and gemini-researcher agents. Launches up to 10 parallel research agents for fast results. USE WHEN user says 'do research', 'research X', 'find information about'..."
- "Chrome DevTools MCP for web application debugging, visual testing, and browser automation. The ONLY acceptable way to debug web apps - NEVER use curl, fetch, or wget."

## Templates Available

- `simple-skill-template.md` - For straightforward capabilities
- `complex-skill-template.md` - For multi-component skills
- `skill-with-agents-template.md` - For skills using sub-agents

## Supplementary Resources

For complete guide with examples: `read ${PAI_DIR}/skills/create-skill/CLAUDE.md`
For templates: `ls ${PAI_DIR}/skills/create-skill/templates/`

## Key Principles

1. **Progressive disclosure**: SKILL.md = quick reference, CLAUDE.md = deep dive
2. **Clear activation triggers**: User should know when skill applies
3. **Executable instructions**: Imperative/infinitive form (verb-first)
4. **Context inheritance**: Skills inherit global context automatically
5. **No duplication**: Reference global context, don't duplicate it
6. **Self-contained**: Skill should work independently
7. **Discoverable**: Description enables Kai to match user intent

Overview

This skill guides creation, updating, and structuring of new skills that extend Kai's capabilities with specialized knowledge, workflows, or tool integrations. It defines a lightweight, repeatable framework for deciding complexity, organizing files, documenting behavior, and validating the skill. Use it to produce consistent, discoverable, and testable skills that follow Anthropic and PAI patterns.

How this skill works

The skill walks you through a step-by-step workflow: clarify purpose and triggers, choose a simple or complex design, create a clear directory layout, write a concise reference file and optional deep-dive document, add the skill to global listings, and run activation tests. It inspects trigger phrases, required tools/dependencies, complexity level, naming, and validation checks to produce a ready-to-deploy skill package. It also includes templates and testing guidance to speed development and ensure consistency.

When to use it

  • Create a new capability for Kai (single or multi-step).
  • Update or refactor an existing skill to match standards.
  • Structure a complex workflow with integrations or subcomponents.
  • Document triggers, tools, and activation conditions for a skill.
  • Add a skill to the system so it becomes discoverable and testable.

Best practices

  • Start by defining a single clear purpose and explicit activation triggers.
  • Choose simple layout for focused capabilities; use an expanded layout for multi-step or agent-based skills.
  • Name skills lowercase with hyphens and keep names descriptive and action- or domain-focused.
  • Provide a concise reference file plus an optional detailed doc for complex behavior—keep imperative instructions and examples.
  • Register the skill in the global available-skills listing so the system prompt can discover it.
  • Test end-to-end with natural language triggers, verify references, and validate examples.

Example use cases

  • Add a quick one-off extractor that responds to 'extract X from Y' with minimal dependencies.
  • Build a complex consulting workflow that spawns sub-agents, requires multiple resources, and includes a detailed methodology doc.
  • Refactor a legacy skill into a discoverable, self-contained package with clear triggers and tests.
  • Create an integration skill for a new toolchain, documenting commands, auth flows, and failure modes.
  • Publish a research skill that launches parallel researcher agents and consolidates results.

FAQ

How should I name a new skill?

Use lowercase with hyphens, choose a descriptive name focused on the action or domain, and avoid generic terms.

How do I verify the skill works after creation?

Trigger it with natural language phrases, confirm the correct file loads and responses match examples, check all references and dependencies, and adjust based on test runs.