home / skills / falkicon / mechanic / k-create-skill

k-create-skill skill

safe

This skill guides creating Claude skills with templates, best practices, and routing patterns to accelerate setup and consistency.

npx playbooks add skill falkicon/mechanic --skill k-create-skill

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

Files (6)

SKILL.md

3.1 KB

---
name: k-create-skill
description: >
  Meta knowledge for creating Claude skills. Provides templates, best practices,
  and patterns for building effective skills with routing tables and reference
  files. Load this when creating new skills or understanding the skill system.
  Triggers: create skill, new skill, skill template, skill architecture, SKILL.md.
---

# Creating Claude Skills

Knowledge for creating and maintaining Claude commands and skills.

## Mechanic Skill System

This project uses a three-prefix taxonomy:

| Prefix | Type | Purpose |
|--------|------|---------|
| `c-` | Commands | Action workflows with explicit steps |
| `s-` | Skills | How-to knowledge (paired with commands) |
| `k-` | Knowledge | Context/background (no command needed) |

See [../../AGENTS.md](../../AGENTS.md) for full system documentation.

## Creating a New Action

To add a new action (e.g., "deploy"):

1. Create `commands/c-deploy.md` with explicit steps
2. Create `skills/s-deploy/SKILL.md` with detailed guidance
3. Add bidirectional links between them

## Creating New Knowledge

To add new context (e.g., "blizzard-api"):

1. Create `skills/k-blizzard-api/SKILL.md`
2. No command needed - the skill IS the context loader

## Skill Structure

```
skills/[skill-name]/
├── SKILL.md              # Required: Main skill file
└── references/           # Optional: Supporting documents
    ├── topic1.md
    └── topic2.md
```

## SKILL.md Format

```markdown
---
name: [prefix]-[name]
description: >
  [What this skill does]. [What content it covers].
  Use when [scenarios]. Triggers: [keyword1], [keyword2], [keyword3].
---

# [Title]

[One-line description]

## Related Commands (for s-* skills only)

- [c-X](../../commands/c-X.md) - [description]

## Capabilities / Key Concepts

1. **[Item 1]** — [Brief description]
2. **[Item 2]** — [Brief description]

## Routing Logic (optional)

| Request type | Load reference |
|--------------|----------------|
| [Topic] | [references/file.md](references/file.md) |
```

## Core Principles

### 1. Progressive Loading

Skills load in stages:
- **Stage 1:** Name + description (always loaded)
- **Stage 2:** SKILL.md body (when skill is relevant)
- **Stage 3:** References (only when explicitly needed)

Design for minimal initial context, deep references.

### 2. Clear Triggers

Description should include trigger words that help Claude know when to use this skill.

### 3. Self-Contained References

Each reference file should be independently useful without requiring other files.

### 4. Actionable Content

Focus on rules, patterns, and examples—not background explanation.

## Routing Logic

| Request type | Load reference |
|--------------|----------------|
| Skill file format | [references/format.md](references/format.md) |
| Routing tables | [references/routing.md](references/routing.md) |
| Description writing | [references/descriptions.md](references/descriptions.md) |
| Reference file design | [references/reference-files.md](references/reference-files.md) |
| Skill architecture | [references/architecture.md](references/architecture.md) |

Overview

This skill provides meta knowledge for creating Claude skills and commands. It supplies templates, best practices, and routing patterns to design clear, actionable skills that load progressively and reference supporting files. Use it when creating new skills, pairing commands with knowledge, or designing routing tables and reference documents.

How this skill works

The skill describes a three-prefix taxonomy (commands, skills, knowledge) and a recommended folder layout for each skill. It explains how to add new actions or context entries, how to structure the main skill file and supporting references, and when to load references versus core content. Routing tables map request types to specific reference files so only needed documents are loaded.

When to use it

When starting a new skill or command and you need a template and structure
When pairing an action workflow with detailed how-to guidance
When adding context-only knowledge that should load on demand
When defining routing logic to load specific reference files
When reviewing or refactoring skill references and loading behavior

Best practices

Use the three-prefix taxonomy: c- for commands, s- for how-to skills, k- for context knowledge
Keep the main skill file minimal; load deep references only when needed
Include clear trigger words in the description to guide selection
Make each reference independently useful and focused on a single topic
Prefer actionable rules, patterns, and short examples over long background sections

Example use cases

Create a new deploy command: add a command workflow and pair it with a how-to skill for configuration and checks
Add API context: create a knowledge skill that provides background on an external API without requiring a command
Design routing: map request types like 'format' or 'architecture' to dedicated reference files
Refactor a skill: split large content into concise main file plus focused references to improve load performance
Write clear triggers: update skill descriptions to include keywords that make the skill discoverable

FAQ

How should I name files and prefixes?

Use the three-prefix system: c- for commands (explicit workflows), s- for how-to skills paired with commands, and k- for context knowledge that stands alone.

When should I load reference files?

Follow progressive loading: keep name and description always available, load the main body when relevant, and load heavy references only on explicit demand or when routing requires them.