Meta-Skills
A meta-skill is a skill that creates other skills. Instead of performing a task directly, it generates a new SKILL.md file — complete with frontmatter, instructions, and optionally supporting files — based on user input. This is the skill-creator pattern: bootstrapping skill development with skills themselves.
Why Meta-Skills Matter
Writing a good skill requires understanding frontmatter fields, tool permissions, string substitutions, and instruction design. A meta-skill encodes all of that knowledge into a template that team members can invoke without being skill experts themselves. The benefits are significant:
- Consistency. Every generated skill follows the same structure, naming conventions, and best practices.
- Speed. Creating a new skill goes from a 10-minute manual process to a 10-second invocation.
- Onboarding. New team members can create skills without learning the SKILL.md specification first.
- Standards enforcement. The meta-skill can enforce project conventions like required tool restrictions, documentation standards, or testing requirements.
A Basic Skill Creator
Here is a meta-skill that generates new skills based on a natural language description provided by the user:
---
description: Create a new skill from a natural language description
allowed-tools:
- Read
- Write
- Bash(mkdir -p)
- Bash(ls)
---
# Skill Creator
The user will describe what they want a skill to do. Your job is to
generate a complete, well-structured SKILL.md file for that skill.
## Input
The user's description: $ARGUMENTS
## Process
1. Parse the user's description to identify:
- The skill's purpose (becomes the description field)
- What tools it needs (becomes allowed-tools)
- What inputs it expects (determines if $ARGUMENTS is needed)
- What output it produces
2. Determine the skill name:
- Convert the purpose to a kebab-case slug
- Example: "commit message generator" → commit-msg
3. Generate the SKILL.md with:
- Frontmatter with description and minimal allowed-tools
- Clear, step-by-step instructions in the body
- Appropriate use of $ARGUMENTS for user input
- Output format specification
4. Write the file to .claude/skills/${skill-name}/SKILL.md
## Rules
- Always use the principle of least privilege for allowed-tools
- Keep the description under 80 characters
- Start the description with a verb
- Include at least one example in the skill body
- Add error handling instructions for edge casesTemplated Skill Creation with $ARGUMENTS
The $ARGUMENTS substitution is the key to making meta-skills flexible. When a user invokes /new-skill review PR changes for security issues, the entire string after the skill name becomes $ARGUMENTS. Your meta-skill parses this to determine what kind of skill to generate.
For more structured input, you can design the meta-skill to expect a specific format:
---
description: Create a new skill from a structured specification
allowed-tools:
- Read
- Write
- Bash(mkdir -p)
---
# Structured Skill Creator
Create a skill based on the user's specification.
## Input Format
The user provides: $ARGUMENTS
Parse this as: `<skill-name> -- <description>`
If no `--` separator is found, treat the entire input as a
description and derive the skill name from it.
## Skill Template
Generate the following structure:
```markdown
---
description: <parsed description, under 80 chars, starts with verb>
allowed-tools:
<determine from description — be conservative>
---
# <Skill Name in Title Case>
<Clear introduction of what this skill does>
## Input
The user provides: $ARGUMENTS
## Steps
<Numbered steps based on the skill's purpose>
## Output
<Description of expected output format>
## Error Handling
- If the input is invalid: <how to handle>
- If no results found: <how to handle>
- If a tool call fails: <how to recover>
```
## File Output
Write to: .claude/skills/<skill-name>/SKILL.md
Confirm creation and show the user how to invoke it.Project-Aware Meta-Skills
The most powerful meta-skills are project-aware. They read your project's configuration, technology stack, and conventions before generating a skill, ensuring the output is tailored to your specific codebase.
---
description: Generate a project-tailored skill by analyzing the codebase first
allowed-tools:
- Read
- Write
- Glob
- Grep
- Bash(mkdir -p)
---
# Smart Skill Creator
Before generating the skill, analyze the project to understand:
1. **Technology stack**: Read package.json, tsconfig.json, or equivalent
to identify the framework (Next.js, Express, etc.), language
(TypeScript, JavaScript), and key libraries.
2. **Existing skills**: Use Glob to find all existing SKILL.md files.
Read them to understand the naming convention, style, and
allowed-tools patterns already in use.
3. **Project structure**: Identify the source directory layout
(src/, app/, lib/, etc.) so the generated skill references
correct paths.
4. **Linting and formatting**: Check for .eslintrc, .prettierrc,
or similar config files to include relevant tool permissions.
## Generation
Based on the user's request ($ARGUMENTS) and the project analysis:
- Match the style of existing skills in the project
- Use the correct file paths for this project's structure
- Include only tools that make sense for the detected stack
- Reference project-specific conventions (test patterns, import aliases)
## Validation
After writing the skill, verify:
- The SKILL.md parses correctly (valid frontmatter)
- Referenced paths exist in the project
- Allowed tools are appropriate for the taskPlace your meta-skill in the project repository (e.g., .claude/skills/new-skill/SKILL.md) so every team member uses the same skill generator. This ensures all skills in the project follow consistent patterns. You can even have the meta-skill read a .claude/skill-standards.md file that defines your team's skill conventions.
Skill Suite Generators
A more advanced pattern is a meta-skill that generates an entire suite of related skills at once. For example, when adding a new domain entity to your application, you might need skills for CRUD operations, testing, and documentation:
---
description: Generate a complete skill suite for a new domain entity
allowed-tools:
- Read
- Write
- Bash(mkdir -p)
---
# Entity Skill Suite Generator
Given an entity name ($ARGUMENTS), generate a complete set of skills:
## Skills to Generate
### 1. Create Entity Skill
- Path: .claude/skills/create-$ARGUMENTS/SKILL.md
- Purpose: Scaffold model, API routes, and basic UI for the entity
- Tools: Read, Write, Bash(mkdir -p)
### 2. Test Entity Skill
- Path: .claude/skills/test-$ARGUMENTS/SKILL.md
- Purpose: Generate unit and integration tests for the entity
- Tools: Read, Write, Bash(npm test)
### 3. Document Entity Skill
- Path: .claude/skills/doc-$ARGUMENTS/SKILL.md
- Purpose: Generate API documentation for the entity's endpoints
- Tools: Read, Write, Glob, Grep
### 4. Migrate Entity Skill
- Path: .claude/skills/migrate-$ARGUMENTS/SKILL.md
- Purpose: Generate database migration for the entity schema
- Tools: Read, Write, Bash(npx prisma migrate)
## Each Skill Must
- Reference the entity name consistently
- Follow the project's existing patterns (read existing files first)
- Include error handling
- Be independently invocable
After generation, print a summary of all created skills.Recursive Skill Patterns
Meta-skills can reference other skills, including themselves. This creates recursive patterns where skills build on each other. For instance, a meta-skill could generate a skill that itself uses the Task tool to dispatch subagents.
While technically possible, deeply recursive skill patterns (a skill that creates a skill that creates a skill) become difficult to debug and reason about. Keep the recursion shallow — one level of meta is usually enough. If you find yourself needing meta-meta-skills, step back and ask whether a single, more flexible meta-skill with better parameterization would achieve the same goal.
Evolving Meta-Skills Over Time
Meta-skills are living documents. As your team's conventions evolve, update the meta-skill to match. When you discover a pattern that should be standard in all new skills (e.g., always include an error handling section, always add a specific allowed-tool), update the meta-skill rather than manually updating each existing skill.
Some teams maintain a changelog within the meta-skill itself:
---
description: Create a new skill following current team standards (v3)
allowed-tools:
- Read
- Write
- Glob
- Bash(mkdir -p)
---
# Skill Creator v3
## Changelog
- v3: Added mandatory error handling section, TypeScript-first tools
- v2: Added project-aware generation, reads existing skills for style
- v1: Basic skill generation from description
## Current Standards (v3)
All generated skills MUST include:
1. A description starting with a verb, under 80 characters
2. Minimal allowed-tools following least privilege
3. A ## Steps section with numbered instructions
4. A ## Error Handling section
5. A ## Output section describing expected output format
...What's Next
You have now completed the Advanced section. You understand subagent execution, agent types, hooks integration, visual output, and meta-skill patterns. The next section covers deployment — how to share skills across teams, distribute them through enterprises, and publish them as plugins.