heilcheng/awesome-agent-skills: A curated list of skills, tools, tutorials, and capabilities for AI coding agents (Claude, Codex, Antigravity, Copilot, VS Code)

Awesome Agent Skills

English | 繁體中文 | 简体中文 | 日本語 | 한국어 | Español

A curated list of skills, tools, and capabilities for AI coding agents.

Table of Contents

• What Are Agent Skills?
• Compatible Agents
• Skill List
• Official Tutorials and Guides
• Using Skills
• Creating Skills
• Community Resources
• Frequently Asked Questions
• Contributing
• License
• References

What Are Agent Skills?

Think of Agent Skills as “how-to guides” for AI assistants. Instead of the AI needing to know everything upfront, skills let it learn new abilities on the fly, like giving someone a recipe card instead of making them memorize an entire cookbook.

Skills are simple text files (called SKILL.md) that teach an AI how to do specific tasks. When you ask the AI to do something, it finds the right skill, reads the instructions, and gets to work.

How It Works

Skills load in three stages:

1. Browse - The AI sees a list of available skills (just names and short descriptions)
2. Load - When a skill is needed, the AI reads the full instructions
3. Use - The AI follows the instructions and accesses any helper files

Why This Matters

• Faster and lighter - The AI only loads what it needs, when it needs it
• Works everywhere - Create a skill once, use it with any compatible AI tool
• Easy to share - Skills are just files you can copy, download, or share on GitHub

Skills are instructions, not code. The AI reads them like a human would read a guide, then follows the steps.

Compatible Agents

The following platforms have documented support for Agent Skills:

Skill List

Official Claude Skills (Document Processing)

Claude provides built-in skills for common document types:

Official OpenAI Codex Skills

Codex supports skills at different scopes:

Official HuggingFace Skills

Community Skills

Community-maintained skills and collections (verify before use):

Skill Collections

Document Processing

Development & Code Tools

Data & Analysis

Integration & Automation

Collaboration & Project Management

Security & Systems

Advanced & Research

Official Tutorials and Guides

Claude and Anthropic

• Using skills in Claude - Official quick start guide
• How to create custom skills - Step-by-step authoring
• Claude Code Skills Documentation - Official reference

GitHub Copilot

• About Agent Skills - GitHub documentation
• VS Code Agent Skills - VS Code integration

Model Context Protocol (MCP)

• MCP Official Documentation - The open standard
• Build your first MCP Server - Python/TypeScript guide
• MCP Server Examples - Official server implementations

Using Skills

Using Skills in Claude.ai

1. Click the skill icon in your chat interface.
2. Add skills from the marketplace or upload custom skills.
3. Claude automatically activates relevant skills based on your task.

Using Skills in Google Antigravity

Antigravity supports two types of skills:

• Workspace Skills: Project-specific skills located in /.agent/skills/
• Global Skills: User-wide skills located in ~/.gemini/antigravity/skills

For more details, see the official documentation.

Using Skills in Claude Code

Place the skill in your configuration directory:

mkdir -p ~/.claude/skills/
cp -r skill-name ~/.claude/skills/

Verify skill metadata:

head ~/.claude/skills/skill-name/SKILL.md

The skill loads automatically and activates when relevant.

Using Skills in Codex

Create a skill:

Use the built-in $skill-creator skill in Codex. Describe what you want your skill to do, and Codex will bootstrap it for you.

If you install $create-plan (experimental) with $skill-installer create-plan, Codex will create a plan before writing files.

You can also create a skill manually by creating a folder with a SKILL.md file:

---
name: skill-name
description: Description that helps Codex select the skill
metadata:
  short-description: Optional user-facing description
---

Skill instructions for the Codex agent to follow when using this skill.

Install new skills:

Download skills from GitHub using the $skill-installer skill:

$skill-installer linear

You can also prompt the installer to download skills from other repositories. After installing a skill, restart Codex to pick up new skills.

Using Skills in VS Code

Skills are stored in directories with a SKILL.md file. VS Code supports skills in two locations:

• .github/skills/ - Recommended location for all new skills
• .claude/skills/ - Legacy location, also supported

Create a skill:

1. Create a .github/skills directory in your workspace
2. Create a subdirectory for your skill (e.g., .github/skills/webapp-testing)
3. Create a SKILL.md file with the following structure:

---
name: skill-name
description: Description of what the skill does and when to use it
---

# Skill Instructions

Your detailed instructions, guidelines, and examples go here...

1. Optionally, add scripts, examples, or other resources to your skill’s directory

Using Skills in Copilot CLI

Adding skills to your repository:

1. Create a .github/skills directory (skills in .claude/skills are also supported)
2. Create a subdirectory for your skill (e.g., .github/skills/webapp-testing)
3. Create a SKILL.md file with your skill’s instructions

SKILL.md structure:

• name (required): A unique lowercase identifier using hyphens for spaces
• description (required): What the skill does and when Copilot should use it
• license (optional): License that applies to this skill
• Markdown body with instructions, examples, and guidelines

Example SKILL.md:

---
name: github-actions-failure-debugging
description: Guide for debugging failing GitHub Actions workflows.
---

To debug failing GitHub Actions workflows:

1. Use \`list_workflow_runs\` to look up recent workflow runs
2. Use \`summarize_job_log_failures\` to get an AI summary of failed jobs
3. Use \`get_job_logs\` for full detailed failure logs if needed
4. Try to reproduce the failure in your environment
5. Fix the failing build

When performing tasks, Copilot decides when to use skills based on your prompt and the skill’s description. The SKILL.md file is injected into the agent’s context.

Using MCP Servers (Claude Desktop)

Edit your configuration file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Example Configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop"
      ]
    }
  }
}

Creating Skills

Skills are instruction bundles that tell the agent how to perform specific tasks. They are not executable code by default.

Skill Structure

skill-name/
├── SKILL.md          # Required: Instructions and metadata
├── scripts/          # Optional: Helper scripts
├── templates/        # Optional: Document templates
└── resources/        # Optional: Reference files

Basic SKILL.md Template

---
name: my-skill-name
description: A clear description of what this skill does.
---

# My Skill Name

Detailed description of the skill's purpose.

## When to Use This Skill

- Use case 1
- Use case 2

## Instructions

[Detailed instructions for the agent on how to execute this skill]

## Examples

[Real-world examples]

MCP Server Example (Python)

For skills that need to connect to external data sources, you can create an MCP server:

pip install fastmcp

server.py:

from fastmcp import FastMCP

mcp = FastMCP("My Server")

@mcp.tool()
def hello_world(name: str = "World") -> str:
    """A simple tool that says hello."""
    return f"Hello, {name}!"

if __name__ == "__main__":
    mcp.run()

Community Resources

LangChain Tools

• Google Search - Wrapper around SerpApi
• Wikipedia - Fetch summaries from Wikipedia
• Python REPL - Execute Python code
• Custom Tools Guide - How to use the @tool decorator

Articles & Research

• I found 50 companies accidentally breaking HIPAA with ChatGPT - Analysis of privacy risks in AI
• I built a Production RAG System for $5/month - Cost-optimization guide for RAG architectures

Frequently Asked Questions

What are Agent Skills?

Agent Skills are instruction files that teach AI assistants how to do specific tasks. Think of them as “how-to guides” that the AI reads and follows. They only load when needed, so the AI stays fast and focused.

How are Agent Skills different from fine-tuning?

Fine-tuning permanently changes how an AI thinks (expensive and hard to update). Agent Skills are just instruction files, you can update, swap, or share them anytime without touching the AI itself.

What’s the difference between Agent Skills and MCP?

They do different things and work great together:

• Agent Skills = teach the AI how to do something (workflows, best practices)
• MCP = help the AI access things (APIs, databases, external tools)

Which AI tools support Agent Skills?

Currently supported: Claude (Claude.ai and Claude Code), GitHub Copilot, VS Code, Codex (OpenAI), Antigravity (Google), Gemini CLI, and Kiro. The list is growing as more tools adopt the standard.

Do Agent Skills run code?

No. Skills are just text instructions, the AI reads and follows them like a recipe. If you need to run actual code, you’d use something like MCP servers alongside skills.

How do I create my first Agent Skill?

1. Create a SKILL.md file with a name and description at the top
2. Write clear, step-by-step instructions in the file
3. Put it in your .github/skills/ or .claude/skills/ folder
4. Test it out!

Full guide: How to create custom skills

Contributing

Contributions are welcome. See CONTRIBUTING.md for full guidelines.

Quick summary:

• Follow the skill template structure
• Provide clear, actionable instructions
• Include working examples where appropriate
• Document trade-offs and potential issues
• Keep SKILL.md under 500 lines for optimal performance
• Verify that skills actually exist before adding them