Skills for AI Agents: What They Are, Where to Get Them, How to Create Them

Skills (plugins, MCP servers) are modular extensions that give an agent new capabilities: file operations, web search, database access, image generation, and much more.

Without skills, an agent is just a chatbot. With skills — it’s a tool that solves real tasks.

← Ready-made AI Agents · AI Agent Architecture → · 🇷🇺 Русский

Contents

1. What Are Skills
2. Platform Comparison
3. MCP — The Universal Standard
4. Where to Get Ready-made Skills
5. How to Create Your Own Skill
6. Example: test-graphics — Image Generation via Third-party API
7. Skill Progression: From Simple to Complex
8. Skills in This Handbook
9. What’s Next

1. What Are Skills

A skill is an additional capability you give to an agent. The agent decides when to use it based on the task.

Example: you ask the agent to “draw an icon for an app”. The agent realizes it can’t draw, finds a suitable image generation skill, calls it — and returns the result.

Different platforms name skills differently:

Despite different names, the principle is the same: you describe what the skill does, and the agent calls it when needed.

2. Platform Comparison

OpenCode / Codex CLI — Skills

Format: Markdown files with instructions + shell scripts.
Location: In .opencode/skills/ folder or in opencode.json config.
How it works: The agent reads the skill description and decides whether to apply it.

Simplest Skill

# test-graphics

Generate test images, photos, icons, placeholders for projects.
Uses Python + free APIs (loremflickr, placehold.co).

Command: python test-graphics.py --width 800 --height 600 --output icon.png

Skill is loaded via config:

{
  "skills": ["test-graphics"]
}

Continue.dev — Context Providers + MCP

Format: JSON config + context provider code.
Location: ~/.continue/config.json + ~/.continue/plugins/.
How it works: Providers load context (files, terminal, git), MCP servers add tools.

{
  "contextProviders": [
    {"name": "file"},
    {"name": "terminal"}
  ],
  "experimental": {
    "mcpServers": [
      {"name": "playwright", "command": "npx", "args": ["@playwright/mcp"]}
    ]
  }
}

Cline — MCP Servers

Format: JSON.
Location: ~/.vscode/extensions/cline/ or in extension settings.
How it works: MCP servers connect as external tools.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    }
  }
}

Cursor — Rules

Format: Markdown files.
Location: .cursorrules (global) or .cursor/rules/ (project-specific).
How it works: The agent reads rules and follows them when generating code.

Aider — Conventions

Format: Markdown + YAML.
Location: CONVENTIONS.md (repo root) or .aider.conf.yml.
How it works: Aider reads conventions and follows code style.

Claude Code — CLAUDE.md

Format: Markdown.
Location: CLAUDE.md in project root.
How it works: Claude Code reads this file on startup and follows instructions.

OpenHands — Microagents

Format: Markdown.
Location: .openhands/microagents/.
How it works: Microagent is a file with instructions for the agent: what it should know about the project, which commands to run.

GitHub Copilot — Custom Instructions

Format: Markdown.
Location: .github/copilot-instructions.md.
How it works: Copilot reads instructions when generating code.

3. MCP — The Universal Standard

Model Context Protocol (MCP) — an open protocol from Anthropic that allows agents to connect any external tools through a unified interface.

How it works:

Agent (client) ←→ MCP Server ←→ External Service (DB, API, files, browser, …)

MCP is supported by:

Platform	MCP Status
Claude Desktop	Native
Claude Code	Native
Cursor	Native
Continue.dev	Experimental
Cline	Native
VS Code (GitHub Copilot)	Via extension
OpenCode / Codex CLI	Via MCP config
Windsurf	Native

Where to get MCP servers:

MCP Server Categories:

• Databases — Postgres, SQLite, MySQL, Turso
• Search & Web — DuckDuckGo, Brave, Jina, Context7
• Dev Tools — GitHub, Git, Docker, Kubernetes
• AI/ML — Ollama, embeddings, RAG
• Files & Storage — Local filesystem, Google Drive, S3
• Browsers — Playwright, Puppeteer
• Communications — Slack, Telegram, Email
• Analytics — BigQuery, Prometheus, Datadog

4. Where to Get Ready-made Skills

MCP Server Catalogs

Largest selection: mcpservers.org — 9,800+ servers.
By category: mcp.directory — 2,300+ servers.
With ratings: findarepo.com/skills/mcp/ — 256+ best.

Skill Repositories

Awesome Lists

• awesome-mcp-servers — curated list
• awesome-cursorrules — rules for Cursor
• awesome-continue — plugins for Continue

5. How to Create Your Own Skill

The process is the same for any platform:

1. Define what the skill does — one specific thing
2. Write the instruction — describe when the agent should call the skill
3. Connect to the agent — via config or file in the appropriate directory

6. Example: test-graphics — Image Generation via Third-party API

Our real use case: the handbook needed to quickly fill demo pages with screenshots, icons, photos — without hiring a designer and without generating via neural network. Solution: a skill that calls free services placehold.co and loremflickr.com via HTTP.

What It Does

• Generates placeholders (placehold.co) with specified dimensions and text
• Gets random photos (loremflickr.com) for realistic placeholders
• Creates icons of specified size
• Works without API keys, without limits, instantly

Skill Structure

.opencode/skills/test-graphics/
├── SKILL.md          # Agent instructions (Markdown)
├── test-graphics.py  # Executable code (Python)
└── requirements.txt  # Dependencies (requests)

Agent Instructions (.opencode/skills/test-graphics/SKILL.md)

# test-graphics

Generate test images, photos, icons, placeholders for projects.
No quality claims — just fill data.
Uses Python + free APIs (loremflickr, placehold.co).

## When to Use
- Need a test image for a mockup
- Need a placeholder icon
- Need to fill a page with images for demonstration

## Command
python test-graphics.py --width <W> --height <H> --output <file> [--type icon|photo|placeholder]

## Examples
- python test-graphics.py --width 800 --height 600 --output hero.png --type photo
- python test-graphics.py --width 64 --height 64 --output icon.png --type icon

## Dependencies
- Python 3
- requests

Skill Code (test-graphics.py)

#!/usr/bin/env python3
"""Generate test images via free APIs."""
import argparse, requests

def generate_placeholder(width, height, text=""):
    url = f"https://placehold.co/{width}x{height}?text={text or f'{width}x{height}'}"
    return url

def generate_photo(width, height):
    return f"https://loremflickr.com/{width}/{height}"

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--width", type=int, default=800)
    parser.add_argument("--height", type=int, default=600)
    parser.add_argument("--type", choices=["photo", "icon", "placeholder"], default="placeholder")
    parser.add_argument("--output", required=True)
    args = parser.parse_args()

    if args.type == "photo":
        url = generate_photo(args.width, args.height)
    else:
        url = generate_placeholder(args.width, args.height, args.type)

    img = requests.get(url).content
    with open(args.output, "wb") as f:
        f.write(img)
    print(f"✓ {args.output} ({args.width}x{args.height})")

Dependencies (requirements.txt)

requests>=2.31.0

Connecting in OpenCode

In opencode.json:

{
  "skills": ["test-graphics"]
}

How the Agent Uses It

You ask: “generate a 64×64 icon for testing”

Agent:

1. Sees test-graphics in available skills
2. Reads SKILL.md — understands parameters
3. Runs: python test-graphics.py --width 64 --height 64 --output icon.png --type icon
4. Returns ready file icon.png

Key Pattern: Third-party Services as “Free Backend”

Pattern: when a task can be solved by an HTTP request to a public API — don’t write your own generation, wrap the call in a skill. This works for: QR codes, barcodes, URL shortening, email validation, geocoding, currency rates, etc.

7. Skill Progression: From Simple to Complex

Skills can evolve through complexity levels:

Level 1: HTTP API Wrapper (like test-graphics)

• Single public endpoint call
• No secrets
• Examples: QR codes, placeholders, random photos, validators

Level 2: Local Logic + File Operations

• Work with files on disk
• Simple data processing
• Examples: format conversion, image resize (Pillow), CSV/JSON parsing

Level 3: MCP Server (Model Context Protocol)

• Persistent process
• Two-way communication with agent
• Standard interface for all MCP clients
• Examples: file access, code search, database work, browser

Level 4: Complex Pipeline with State

• Multi-step processes
• Caching, retries, rate limiting
• Own API or task queue
• Examples: RAG pipeline, code generation with tests, CI/CD integration

Level 5: Skill Pack / Plugin Ecosystem

• Set of related skills for a domain
• Versioned (data-science, web-dev, devops)
• Marketplace, versioning, dependencies
• Examples: .opencode/skills/data-science/, .opencode/skills/frontend/

Skill Maturity Checklist

Criterion	Level 1	Level 2	Level 3	Level 4	Level 5
Needs API key
State between calls
Works offline
MCP standard
Versioning
Dependencies on other skills

Recommendation: Start with Level 1

1. Find a routine task you do manually
2. Is there a public API? → wrap in Level 1 skill
3. No API? → write local logic (Level 2)
4. Need context/memory/two-way dialog? → MCP (Level 3)

8. Skills in This Handbook

As Awesome AI Handbook evolves, we add skills for different platforms.
Watch the folder:

awesome-ai-handbook/
└── .opencode/
    └── skills/
        └── test-graphics/    ← example above

Planned:

• handbook-qa — search handbook content
• model-benchmark — run benchmarks on local hardware
• agent-scaffold — generate agent code for chosen framework

9. What’s Next

In section: architecture · evaluation · frameworks · memory · multi-agent · ollama-for-agents · orchestrators · patterns · prompting · ready-made · safety · skills
Related sections: Zero Level · Local Models · Use Cases · Resources
Navigation: ← AI Agents · ↑ Back to main · 🇷🇺 Русский