create-skill
Guide for creating effective skills following best practices. Use when creating or updating skills that extend agent capabilities.
Best use case
create-skill is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Guide for creating effective skills following best practices. Use when creating or updating skills that extend agent capabilities.
Teams using create-skill should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/create-skill/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How create-skill Compares
| Feature / Agent | create-skill | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Guide for creating effective skills following best practices. Use when creating or updating skills that extend agent capabilities.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Create Skill
Guide for creating effective skills that extend agent capabilities with specialized knowledge, workflows, and tool integrations.
## About Skills
Skills are modular, self-contained packages that extend agent capabilities by providing specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific domains or tasks.
### 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
## Progressive Disclosure Principle
**The 200-line rule is critical.** SKILL.md must be under 200 lines. If you need more, split content into `references/` files.
### Three-Level Loading System
1. **Metadata (name + description)** - Always in context (~100 words)
2. **SKILL.md body** - When skill triggers (<200 lines, ideally <500 lines for optimal performance)
3. **Bundled resources** - As needed by agent (unlimited)
### Why Progressive Disclosure Matters
- 85% reduction in initial context load
- Activation times drop from 500ms+ to under 100ms
- Agent loads only what's needed, when it's needed
- Skills remain maintainable and focused
## Skill Structure
```
skill-name/
├── SKILL.md (required, <200 lines)
│ ├── YAML frontmatter metadata (required)
│ │ ├── name: (required)
│ │ └── description: (required)
│ └── Markdown instructions (required)
└── Bundled Resources (optional)
├── scripts/ - Executable code
├── references/ - Documentation loaded as needed
└── assets/ - Files used in output
```
## Core Principles
### Concise is Key
The context window is a shared resource. Your skill shares it with everything else the agent needs. Be concise and challenge each piece of information:
- Does the agent really need this explanation?
- Can I assume the agent knows this?
- Does this paragraph justify its token cost?
### Set Appropriate Degrees of Freedom
- **High freedom**: Text-based instructions for multiple valid approaches
- **Medium freedom**: Pseudocode or scripts with parameters
- **Low freedom**: Specific scripts with few/no parameters for fragile operations
### Test with All Models
Skills act as additions to models, so effectiveness depends on the underlying model. Test your skill with all models you plan to use it with.
## References
For detailed guidance, see:
- `references/progressive-disclosure.md` - 200-line rule and references pattern
- `references/skill-structure.md` - SKILL.md format and frontmatter details
- `references/examples.md` - Good skill examples
- `references/best-practices.md` - Comprehensive best practices guideRelated Skills
create-agents-md
Create AGENTS.md files for project-specific inline rules. Use when adding small, project-specific instructions that should be committed in repos.
typescript
TypeScript standards and best practices with modern tooling. Use when working with TypeScript or TypeScript React files.
software-engineer
Core software engineering principles for code style, documentation, and development workflow. Applies when editing code, working in software repositories, or performing software development tasks.
semantic-git
Manage Git commits using conventional commit format with atomic staging. Always generate plain git commands before running them and offer to let the user run them manually.
python
Python development guidelines and best practices. Use when working with Python code.
psi
Plan-spec-implement workflow for structured development. Only use when explicitly directed by user or when mentioned in project AGENTS.md file. Generates ephemeral plans in ~/.dot-agent/, applies specs to project docs, then implements test-first.
media-processing
Media processing utilities for images, audio, and video using FFmpeg and ImageMagick. Use when working with media conversion, optimization, or batch processing tasks.
frontend-engineer
Frontend development guidelines for React/TypeScript applications. Modern patterns including Suspense, lazy loading, useSuspenseQuery, file organization with features directory, MUI v7 styling, TanStack Router, performance optimization, and TypeScript best practices. Use when creating components, pages, features, fetching data, styling, routing, or working with frontend code.
context-engineering
Master context engineering for AI agent systems. Use when designing agent architectures, debugging context failures, optimizing token usage, implementing memory systems, building multi-agent coordination, evaluating agent performance, or developing LLM-powered pipelines. Covers context fundamentals, degradation patterns, optimization techniques, compression strategies, memory architectures, multi-agent patterns, evaluation, tool design, and project development.
code-review
Code review practices emphasizing technical rigor, evidence-based claims, and verification. Use when receiving code review feedback, completing tasks requiring review, or before making completion claims.
cli-building
Build command-line interfaces with async-first design, composable commands, and proper output formatting. Use when creating CLI tools, commands, or interactive terminal applications.
backend-engineer
Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.