Agent Skills: The Complete 2026 Guide to AI Agent Superpowers (260+ Skills Explained)

If you use Gemini CLI, Claude Code, Cursor, or GitHub Copilot to write code — you are likely leaving 80% of their capability unused.

That untapped capability has a name: Agent Skills.

In this guide, I’ll explain exactly what agent skills are, how they work under the hood, how to install and manage them, and walk you through all 260+ skills organized by category — so you can build faster, smarter, and with less friction starting today.

What You’ll Learn

In this article, you’ll discover:

• What agent skills are and why they matter
• The 6-step lifecycle of an agent skill
• How to set up and manage your skill library
• A complete reference of 260+ skills across 12+ domains
• How to create your first custom skill
• Strategies for token optimization

What Are Agent Skills? (The Honest Definition)

Agent skills are modular, self-contained directories that give AI coding agents on-demand specialized expertise.

Each skill is a folder containing a SKILL.md file — a structured instruction document with a name, description, and detailed procedural guidance. When you start an agent session, only the skill’s name and one-line description are loaded into the context window. The full instructions only load when the agent detects you need that skill and you approve the activation.

This design principle — called progressive disclosure — is the key innovation. Compare how skills stack up against the alternatives:

Agent skills were introduced as an open standard by Anthropic, later adopted natively by Google’s Gemini CLI, and are now compatible with most major AI coding environments. The canonical registry lives at skills.sh.

How Agent Skills Work: The 6-Step Lifecycle

Understanding the lifecycle helps you use skills strategically rather than blindly:

Step 1 — Discovery

When you start a Gemini CLI (or Claude Code) session, the agent scans configured skill directories. It finds every SKILL.md and extracts only the name and description frontmatter. These two fields are injected into the system prompt. Nothing else.

Step 2 — Monitoring

As you work, the agent continuously pattern-matches your requests against all loaded skill descriptions.

Step 3 — Match Detected

When your request matches a skill’s description (e.g., you ask “review this code for security issues” and security-review skill is present), the agent calls an internal activate_skill tool.

Step 4 — Your Approval

A UI prompt appears showing: skill name, its stated purpose, and the directory path. You approve or reject.

Step 5 — Full Load

Upon approval, the complete SKILL.md body, all bundled scripts, references, and asset files are loaded into conversation history. The skill directory is added to the agent’s allowed file paths.

Step 6 — Execution

The agent proceeds with the skill’s specialized procedural guidance prioritized for the rest of the session. It behaves like a domain expert just joined your session.

The Agent Skills Open Standard

Agent skills are not proprietary to any single company. They follow an open standard — meaning a skill you write once works across:

• Google Gemini CLI (native first-class support)
• Anthropic Claude Code (native support)
• GitHub Copilot (via extensions)
• Cursor (via .cursorrules integration)
• Any agent that reads from ~/.agents/skills/ (the universal path)

The community registry at skills.sh hosts thousands of published skills you can install with a single command. As of 2026, this is the fastest-growing open ecosystem in AI developer tooling.

Where Skills Live: Discovery Tiers

Skills are loaded from three tiers, in priority order:

1. Workspace Skills (Project-Specific)

Path: .gemini/skills/ or .agents/skills/ inside your project root

• Committed to version control
• Shared with your entire team
• Override user-level skills of the same name
• Best for: project-specific conventions, tech stack rules

2. User Skills (Your Global Library)

Path: ~/.gemini/skills/ or ~/.agents/skills/

• Available in every project on your machine
• Personal skills that follow you everywhere
• Best for: your coding standards, preferred stacks, personal workflows

3. Extension Skills

Path: ~/.gemini/extensions/<extension-name>/skills/

• Bundled by installed CLI extensions
• Auto-managed, no manual setup
• Best for: official skills from Google, Anthropic, Vercel, Firebase, etc.

Pro tip: Use ~/.agents/skills/ as your canonical master store and symlink from agent-specific paths. This future-proofs your setup as new agents adopt the standard.

Complete Setup Guide: New Project Checklist

One-Time Global Setup (Do Once)

If you installed skills via rulesync (as many developers do), sync them to your agent:

# Windows PowerShell — sync rulesync → Gemini CLI
Get-ChildItem ~/.rulesync/skills/ -Directory | ForEach-Object {
    $dst = "~/.gemini/skills/$($_.Name)"
    if (-not (Test-Path $dst)) {
        Copy-Item -Recurse -Force $_.FullName $dst
        Write-Host "✅ $($_.Name)"
    }
}

# macOS/Linux equivalent
for skill in ~/.rulesync/skills/*/; do
  name=$(basename "$skill")
  dst="$HOME/.gemini/skills/$name"
  if [ ! -d "$dst" ]; then
    cp -r "$skill" "$dst"
    echo "✅ $name"
  fi
done

Per-Project Setup

# Create workspace skills folder
mkdir -p .gemini/skills

# Copy a user skill into your project
cp -r ~/.gemini/skills/nextjs-developer .gemini/skills/

# Or symlink it (saves disk space, auto-updates)
ln -s ~/.gemini/skills/react-expert .gemini/skills/react-expert

# Install from skills.sh registry
npx skills install vercel-labs/nextjs-developer
npx skills install anthropics/prompt-engineer

# Install to user directory (available globally)
npx skills install --user react-expert

Managing Skills in a Session

# List all discovered skills
/skills list

# Disable a skill temporarily (remove from context)
/skills disable game-developer

# Re-enable it
/skills enable game-developer

# Reload after adding new skills to disk
/skills reload

# Link an external skill via symlink
/skills link /path/to/my-custom-skill

# From terminal (outside a session)
gemini skills list
gemini skills install <skill-name>

The Complete 260+ Agent Skills Reference

Below is every skill organized by domain. Use Ctrl+F to find what you need.

🤖 AI & Agent Engineering (32 Skills)

For developers building autonomous agents, multi-agent systems, and AI pipelines:

🧑‍💻 Code Quality & Standards (22 Skills)

🌐 Frontend (20 Skills)

⚙️ Backend (30 Skills)

🗄️ Databases (7 Skills)

☁️ Infrastructure & DevOps (14 Skills)

🔐 Security (12 Skills)

🔤 Languages (35 Skills)

📱 Mobile (7 Skills)

🤖 ML & Data (10 Skills)

🎨 Content & Media (12 Skills)

🛠️ Dev Tooling & Workflows (25+ Skills)

🏥 Healthcare (4 Skills)

📦 Operations & Business (24 Skills)

Quick-Start Skill Stacks by Project Type

Don’t activate all 260 skills — pick the right pack for your current project:

🚀 Full-Stack Web App (Next.js + Postgres)

• nextjs-developer
• react-expert
• typescript-pro
• postgres-pro
• backend-patterns
• api-design
• tdd-workflow
• git-workflow
• deployment-patterns

🛒 SaaS Product with Payments

• nextjs-developer
• customer-billing-ops
• finance-billing-ops
• email-ops
• seo
• monitoring-expert
• deployment-patterns
• security-review

🤖 AI Agent / Automation Tool

• agentic-engineering
• autonomous-loops
• create-subagents
• rag-architect
• prompt-engineer
• mcp-developer
• cost-aware-llm-pipeline
• safety-guard

How to Create Your Own Agent Skill

Creating a skill is one of the highest-leverage things you can do as a developer. Your custom skill encodes your team’s specific conventions, preferred libraries, and coding standards — making every AI session start with expert context about your project.

Step 1: Create the Skill Directory

# For global user skill
mkdir -p ~/.gemini/skills/my-custom-skill

# For project-specific skill
mkdir -p .gemini/skills/my-custom-skill

Step 2: Write the SKILL.md

This is the only required file. The description field is critical — it determines when the skill auto-activates:

---
name: my-custom-skill
description: >-
  Use this skill when the user wants to build, review, or debug anything
  related to [your tech stack]. Activates when working on [specific triggers
  like: \"React components\", \"database queries\", \"authentication flows\"].
---

# My Custom Skill

## When to Use This Skill
- Building [X] component or feature
- Reviewing [Y] type of code
- Debugging [Z] category of issues

## Standards & Conventions
1. Always use [your convention]
2. Prefer [library A] over [library B] because [reason]
3. Error handling pattern: [your pattern]

## Step-by-Step Workflow
1. [First step]
2. [Second step]
3. [Verification step]

## Common Pitfalls to Avoid
- Never [anti-pattern 1]
- Don't [anti-pattern 2] unless [condition]

TL;DR

• Agent Skills are modular, on-demand expertise for AI coding agents.
• Progressive Disclosure keeps context windows lean and tokens cheap.
• Open Standard means skills are portable across Gemini CLI, Claude Code, and more.
• Custom Skills allow teams to encode their own engineering standards into AI context.

If you found this useful, subscribe to my newsletter below for more AI research, coding tutorials, and no-BS tech insights.

Have a skill recommendation or spotted an error? Reach out on LinkedIn or email me at business@hassanali.site.

Last updated: April 29, 2026