You've learned what skills are (Part 1) and how to set them up across agents (Part 2). Now we build one from scratch, explore the discovery tools that make skills feel like npm for AI agents, and point you to the best sources for pre-built skills you can install today.
Build a Skill in 10 Minutes: Code Review Checklist
Let's create a practical skill that enforces your team's code review standards. We'll follow the official Agent Skills specification so the result works across Claude Code, GitHub Copilot, Codex, and Cursor.
Step 1: Create the directory
The directory name must match the name field in your SKILL.md:
# Use .github/skills/ for maximum cross-agent compatibility
mkdir -p .github/skills/code-review-checklist
Step 2: Understand the SKILL.md structure
Every SKILL.md has two parts: YAML frontmatter (metadata) and a Markdown body (instructions). Here are the fields defined by the spec:
Field | Required | Constraints |
|---|---|---|
| Yes | Max 64 chars. Lowercase letters, numbers, hyphens only. Must match directory name. |
| Yes | Max 1,024 chars. Describe what it does and when to use it. Include trigger keywords. |
| No | License name or reference to a bundled LICENSE file. |
| No | Max 500 chars. Environment requirements (target product, system packages, network access). |
| No | Arbitrary key-value pairs (author, version, tags). |
| No | Space-delimited list of pre-approved tools. (Experimental) |
The body has no format restrictions — write whatever helps agents perform the task. Recommended sections: step-by-step instructions, examples of inputs/outputs, and common edge cases. Keep the body under 500 lines; move detailed reference material to separate files.
Step 3: Write the SKILL.md
---
name: code-review-checklist
description: >-
Perform code reviews following our team standards. Use when
asked to review code, check a PR, audit code quality, or
when the user mentions "review", "PR feedback", or "code quality".
Do NOT use for writing new code or debugging.
license: MIT
metadata:
author: your-team
version: "1.0"
---
# Code Review Checklist
When reviewing code, systematically check each category
and provide structured feedback.
## Security
- No hardcoded secrets or API keys
- Input validation on all user-facing endpoints
- SQL queries use parameterized statements
- Auth checks on every protected route
## Performance
- No N+1 query patterns in data fetching
- Database queries use appropriate indexes
- Large datasets use pagination or streaming
- No unnecessary re-renders in React components
## Maintainability
- Functions under 50 lines
- No magic numbers — use named constants
- Error messages are actionable, not generic
- Complex logic has inline comments explaining "why"
## Testing
- New functions have corresponding unit tests
- Edge cases covered (null, empty, boundary values)
- Integration tests for new API endpoints
- Test names describe the expected behavior
## Output Format
Structure every review as:
1. **Summary** — One-sentence overall assessment
2. **Critical** — Must-fix issues (security, bugs)
3. **Improvements** — Suggested enhancements
4. **Praise** — What's done well (always include this)
Step 4: Validate and use
Validate your skill against the spec using the reference library:
npx skills-ref validate ./code-review-checklist
Then in any coding agent, say: "Review the changes in my current branch." The agent matches your prompt to the skill's description, loads the instructions, and follows your exact review process. Commit the skill to your repo and every teammate's agent picks it up automatically.
Packaging and Testing Your Skill
Packaging for distribution
When your skill directory is complete, you can share it in several ways. For Claude.ai uploads, create a ZIP file with the skill folder as its root:
Correct: my-skill.zip → my-skill/ → SKILL.md + resources/ Incorrect: my-skill.zip → SKILL.md (files directly in ZIP root)
For repository sharing, just commit the directory — other developers install it with npx skills add or by copying it into their skills folder.
Testing checklist
Before deploying:
Review your SKILL.md for clarity — would a new team member understand it?
Verify the description accurately reflects when the skill should trigger
Check that all referenced files exist at the correct relative paths
Run
npx skills-ref validate ./your-skillto catch spec violations
After installing:
Try several prompts that should trigger it — confirm it activates
Try prompts that should not trigger it — confirm it stays silent
Review the agent's thinking/reasoning to verify it loaded the skill
Iterate on the description if the skill isn't firing when expected
These patterns come from Anthropic's official authoring guidelines and from reviewing production skills across the ecosystem.
Keep it focused. Create separate skills for different workflows. Multiple focused skills compose better than one monolithic skill — Claude can use several skills together in a single task automatically.
Start simple, expand later. Begin with basic markdown instructions before adding scripts. Add scripts/, references/, and assets/ directories as the skill matures.
Write the description like a routing rule. Claude uses the description to decide when to invoke your skill. Be specific, include trigger keywords, and state when it should not be used.
Include examples. Show example inputs and outputs so the agent understands what success looks like. Real code from your codebase teaches better than abstract guidelines.
Match specificity to fragility. Use text instructions (high freedom) when multiple approaches are valid. Use concrete scripts (low freedom) when consistency is critical.
Test incrementally. Test after each significant change rather than building a complex skill all at once.
Security. Don't hardcode API keys or passwords. Review community skills before enabling them. Use MCP connections for external service access rather than embedding credentials.
Follow the open spec. Build against agentskills.io/specification so your skills work across every platform that adopts the standard.
Adding Scripts and References
For tasks that need deterministic reliability, skills can include executable code.
Example: A skill with a validation script
deployment-validator/
├── SKILL.md
├── scripts/
│ └── validate_env.py
└── references/
└── required-env-vars.md
SKILL.md:
---
name: deployment-validator
description: >-
Validate deployment readiness. Use before deploying to
staging or production. Checks env vars, migrations, and
dependency health.
---
# Deployment Validator
Before any deployment, run the validation script:
```bash
python scripts/validate_env.py
If validation fails, check references/required-env-vars.md for the full list of required environment variables per environment.
The agent runs `validate_env.py` and receives only its output — the script's source code never enters the context window. This is both token-efficient and deterministic.
---
## 10 Skills to Build This Week
Each takes 15–30 minutes and pays for itself within the first week:
1. **PR Description Generator** — Reads git diff, generates structured PR description from your team's template
2. **Database Migration Reviewer** — Flags irreversible changes, missing indexes, potential data loss
3. **API Documentation Writer** — Generates OpenAPI specs from route handlers in your preferred format
4. **Component Scaffold** — Creates React/Vue/Svelte components with your project's file structure, tests, and stories
5. **Dependency Audit** — Checks for outdated, vulnerable, or license-incompatible packages
6. **Commit Message Formatter** — Enforces conventional commits with your team's scopes and types
7. **Environment Setup Guide** — Walks agents through full dev environment setup (great for onboarding)
8. **Performance Profiler** — Identifies common anti-patterns specific to your stack
9. **Accessibility Checker** — Reviews UI code against WCAG guidelines and suggests fixes
10. **Design Doc Writer** — Generates architecture decision records following your team's ADR template
---
## The Skills Ecosystem: Discovery and Distribution
The ecosystem around skills has matured rapidly. Here are the tools that make skills feel like a proper package ecosystem.
### skills.sh — The npm for Agent Skills
Vercel launched **skills.sh** as a public directory and leaderboard for skill packages. Browse skills by category, see install counts, and discover what other developers are using. It's populated automatically when skills are installed via the `npx skills` CLI.
**URL:** [skills.sh](https://skills.sh)
### Vercel Skills CLI (`npx skills`)
The package manager that works across 37+ agents. Install, remove, list, and manage skills from any source:
```bash
# Discover what's in a repo
npx skills add vercel-labs/agent-skills --list
# Install a specific skill to all your agents
npx skills add anthropics/skills --skill pdf --agent '*' -g -y
# Initialize a new skill from scratch
npx skills init my-new-skill
OpenSkills
A universal skills loader that generates Claude Code-compatible <available_skills> XML blocks for any agent. Particularly useful for Cursor and Windsurf where native skill support may require nightly builds:
npm i -g openskills
openskills install anthropics/skills
openskills sync # Updates AGENTS.md with skill metadata
openskills read skill-creator # Preview a skill's contents
SkillPort
An MCP-based approach to skill management. Run it as an MCP server and any MCP-compatible client gets access to your skills:
uv tool install skillport
skillport add anthropics/skills skills
skillport validate # Check skills against the spec
Works with Cursor, Copilot, Windsurf, Cline, Codex, and any MCP-compatible client.
Mintlify Auto-Generated Skills
Mintlify now generates skill.md files from documentation sites automatically, served at /.well-known/skills/default/skill.md. Any developer tool with Mintlify-powered docs becomes a skill that agents can consume. The implication: documentation is increasingly written to serve both humans and AI agents.
Where to Find Pre-Built Skills
Here are the best sources, organized by what you'll find:
Official Repositories
Source | URL | What's There |
|---|---|---|
Anthropic Skills |
| 25+ skills — documents, frontend, design, testing, enterprise |
Vercel Agent Skills |
| React/Next.js best practices, UI review, deployment, AI SDK |
GitHub Awesome Copilot |
| 30+ skills plus collections for DevOps, security, databases, cloud |
OpenAI Skills |
| Codex-optimized skills and examples |
Community Collections
Source | URL | What's There |
|---|---|---|
awesome-claude-skills (travisvn) |
| 50+ categorized skills with timeline and FAQ |
awesome-claude-skills (ComposioHQ) |
| Software architecture, prompt engineering, kaizen, n8n automation |
Context Engineering Skills |
| 107 skills across 27 plugins — agent architecture, evaluation, TDD |
awesome-agent-skills (heilcheng) |
| Cross-agent setup guides with MCP integration examples |
LobeHub Marketplace |
| Web-based directory of community-submitted skills |
Quick Install: Recommended Starter Pack
Run these commands to get immediate value:
# Document creation (PDF, Word, Excel, PowerPoint)
npx skills add anthropics/skills --skill pdf --skill docx --skill xlsx --skill pptx -g -y
# React/Next.js development
npx skills add vercel-labs/agent-skills --skill vercel-react-best-practices -g -y
# UI quality review (100+ rules)
npx skills add vercel-labs/agent-skills --skill web-design-guidelines -g -y
# Meta-skill: helps you create better skills
npx skills add anthropics/skills --skill skill-creator -g -y
What's Coming Next in the Ecosystem
The pace of development suggests a few clear trends.
Documentation-as-skills is becoming standard. Between Mintlify's auto-generation, Cloudflare's RFC for /.well-known/skills/, and Vercel's skills CLI discovering skills from URLs automatically, the line between "good documentation" and "agent skill" is disappearing. If you maintain developer docs, you should be thinking about how they'll be consumed by agents.
Marketplaces will mature. skills.sh is the early leader. Expect curated, searchable directories with ratings, reviews, and one-click installs — similar to what VS Code extensions or npm packages offer today.
Enterprise skill sharing. GitHub has signaled that organization-level and enterprise-level skills are coming for Copilot. Anthropic's API already supports organization-wide custom skills. The pattern is clear: teams will manage shared skill libraries the way they manage shared component libraries.
Skills + MCP = compound capabilities. The most powerful setups will combine skills (what to do) with MCP servers (how to access tools). A "database migration reviewer" skill that can also query your actual database via MCP is dramatically more useful than either piece alone.
Introducing the AI Native Skills Directory
We're building a searchable, curated Skills Directory at ainative.medhavi.dev — organized by development domain with one-click install commands for every major agent.
What you'll find:
Skill Packs organized by role: Frontend, Backend, DevOps, Testing, Design, Architecture, Productivity
One-command installs for Claude Code, Copilot, Codex, and Cursor
Skill previews so you can read the SKILL.md before installing
Community submissions — share your skills with the community
We're crawling the major skill repositories and indexing them automatically so the directory stays current. If you've built a skill you want listed, reply to this email with a link to your repo.
Your Action Plan
Build one custom skill today using the code review walkthrough above — 10 minutes, immediate payoff
Install the starter pack — 4 commands, pre-built expertise for documents and React
Browse the ecosystem at skills.sh and the repos listed above
Share skills with your team by committing them to your repo
Subscribe for the Skills Directory launch and weekly curated skill picks
The 30 minutes you invest in your first skill will save hours of re-prompting across every session that follows. Skills compound. Start now.
What skill did you build? Reply with a link — I'll feature the best ones in a future issue.
References & Further Reading:
Agent Skills Specification: agentskills.io/specification
Anthropic — How to create custom Skills: support.claude.com
Anthropic — Skill authoring best practices: platform.claude.com/docs
Anthropic Engineering: Equipping agents for the real world with Agent Skills
Anthropic Skills Repository: github.com/anthropics/skills
Vercel Agent Skills: github.com/vercel-labs/agent-skills
Vercel Skills CLI: github.com/vercel-labs/skills
Skills Directory: skills.sh
GitHub Community Skills: github.com/github/awesome-copilot
awesome-claude-skills: github.com/travisvn/awesome-claude-skills
Context Engineering Skills: github.com/muratcankoylan/Agent-Skills-for-Context-Engineering
OpenSkills: github.com/numman-ali/openskills
SkillPort: github.com/gotalab/skillport
This is Part 3 of our 3-part Agent Skills series:
Part 1: What Are Agent Skills?
Part 3: Build Your First Custom Skill + The Skills Ecosystem (You are here)
