Agent Skills: How to Extend Your AI Agents in 2026

The TL;DR

The 15 best agent skills turn a general AI agent into a specialist by packaging reusable workflows it can load on demand. Most are free, open, and quick to install.

• • One Command, Dozens of Skills

  Most skills install through a single terminal command or a Claude Code plugin bundle, and the same format works across more than two dozen AI agents.

• • Skills Teach, MCP Connects

  Skills teach an agent how to complete a task, while MCP gives it access to external tools and systems. Practical workflows often need both.

• • Trust the Source

  Skills may include executable code, so review the author, repository, permissions, and files before installing them, just as you would with any new dependency.

A general-purpose agent can write a quarterly report, but ask it to match your company’s exact deck format and it guesses. It knows Python, but it does not know that your team files pull requests with a specific title structure and a testing checklist. That gap between raw capability and your way of working is where most agent projects stall.

Agent skills close that gap. Instead of re-explaining the same procedure in every prompt, you write it down once as a folder the agent reads on demand. The agent keeps its general intelligence and gains your specific expertise on top.

This blog covers what agent skills are, the best ones to add first, how they differ from MCP, and how to build your own. By the end you will know exactly which skills to install this week and how to package your own workflow into one.

What agent skills actually are

An agent skill is a folder with a SKILL.md file at its root. That file carries two required pieces of metadata, a name and a description, followed by the instructions the agent should follow. The folder can also bundle scripts, reference documents, and templates the agent pulls in when a task calls for them.

Anthropic introduced the format in October 2025 and published it as an open standard two months later. Because the spec is open, a skill you write for Claude Code also runs in other agents that adopted it, including Cursor, GitHub Copilot, VS Code, Gemini CLI, OpenAI Codex, OpenCode, and Block’s Goose. Write the skill once, reuse it wherever your team works.

The official anthropics/skills repository had passed 149,000 stars on GitHub as of June 2026, a growth curve that echoes the pace of change already playing out around MCP itself.

How agent skills work

Skills load through progressive disclosure, a fancy term for a simple idea. The agent only reads what the current task needs.

It happens in three stages. At startup, the agent loads just the name and description of every installed skill, enough to know what each one is for. When your request matches a skill’s description, the agent reads the full SKILL.md into context. If the instructions point to a bundled script or reference file, the agent opens that only at the moment it becomes relevant.

The payoff is room. An agent can keep dozens of skills on hand while spending almost no context window on the ones it is not using right now. Skills can also include code the agent runs directly, so a task like extracting form fields from a PDF runs a real script instead of guessing token by token.

15 best AI agent skills to extend your agents in 2026

Every skill here clears the same bar. It comes from a verifiable source, either Anthropic’s official library or a named author on skills.sh, the closest thing skill discovery has to a package marketplace. It solves a job people repeat, and it runs across more than one agent. Picks favor everyday utility over novelty.

The list alternates Anthropic and skills.sh skills. Anthropic’s install in Claude Code as plugin bundles, where one example-skills install covers seven of the skills below. Everything else, and any Anthropic skill on agents like Cursor or Codex, installs with npx skills add owner/repo. Read a skill’s code before you run it.

1. Document skills: docx, pdf, pptx, xlsx

Document skills powers Claude’s own file creation, which makes them the most practical place to start. They turn an agent from something that drafts text in a chat window into something that produces the finished file you actually send, and they run real code rather than guessing at file structure, so the output opens cleanly in Office and Adobe tools. The docx skill builds Word files with headings, tables of contents, tracked changes, find-and-replace, and embedded images. The pdf skill extracts text and tables, merges and splits documents, fills PDF forms, OCRs scanned pages, and encrypts or decrypts files. The pptx and xlsx skills build slide decks with speaker notes and spreadsheets with working formulas and charts, and clean messy CSV data into proper tables.

Best For

Operations, finance, and marketing teams who hand off finished documents and want to skip the copy-paste-into-a-template step.

Installation: /plugin install document-skills@anthropic-agent-skills

2. Find-skills

Find-skills is a meta-skill with one job, finding other skills, and it is the single most-installed skill on skills.sh. Instead of you stopping to search for the right capability, the agent queries the skills.sh catalog itself from inside an active task, picks a match for the work in front of it, and installs it on the spot without leaving the session. It functions as a package manager for agent capabilities, so you install one skill rather than pre-loading dozens, and the toolkit grows as the work demands.

Best For

Anyone who would rather let the agent expand its own toolkit than curate a skill library by hand.

Installation: npx skills add vercel-labs/skills

3. Skill-creator

Skill-creator is Anthropic’s meta-skill for building other skills. It scaffolds a new skill to spec, writes a valid SKILL.md with the right frontmatter, and organizes bundled scripts and references the way the format expects. It also runs evals that benchmark how reliably your skill fires on real tasks, and it tunes the skill’s description, which is the single biggest factor in whether an agent picks it up at the right moment.

Best For

Teams turning their repeated workflows into reusable skills who want them to work on the first try, not the fifth.

Installation: /plugin install example-skills@anthropic-agent-skills

4. Vercel frontend skills

Vercel frontend skills are Vercel’s own installable set of React and Next.js conventions, published as a single bundle so an agent stops guessing at frontend best practices. With it, the agent stops producing dated class components and starts following current patterns for the App Router, server components, and composition. The collection encodes Vercel’s React and Next.js best practices, adds web design guidelines so generated UI follows sensible layout and spacing rules, and ships both a one-command deploy-to-Vercel skill and a React Native variant. For a Next.js shop, this is the difference between code you merge and code you rewrite.

Best For

Front-end teams building in React or Next.js who want agent output that matches today’s conventions.

Installation: npx skills add vercel-labs/agent-skills

5. mcp-builder

mcp-builder is Anthropic’s guide for building Model Context Protocol servers, covering FastMCP in Python and the official MCP SDK in Node or TypeScript so you are not translating examples between stacks by hand. Connecting an agent to your own systems usually means writing a server, and a poorly described one is easy for the model to misuse, so mcp-builder pays particular attention to how tools are named, described, and shaped so a model calls them correctly. The servers it produces plug into any MCP-compatible client.

Best For

Developers wrapping an internal or third-party API so their agents can use it.

Installation: /plugin install example-skills@anthropic-agent-skills

6. Shadcn/ui

The shadcn/ui skill teaches an agent how to add and compose real shadcn components the way the library intends, instead of hand-rolling components that look almost right and quietly break your design system. Because it comes from the shadcn/ui project itself, it tracks the components and patterns the system actually ships rather than approximating them from memory.

Best For

Front-end developers standardized on shadcn/ui and Tailwind who want consistent components from their agent.

Installation: npx skills add shadcn/ui

7. Webapp-testing

Webapp-testing is Anthropic’s skill for driving a live browser through Playwright, so an agent exercises real user flows the way a person would instead of declaring a feature done without ever opening it in a browser. It captures screenshots and reads browser console logs to surface failures, and it verifies behavior end to end rather than trusting that the code compiled. This is the skill that catches the bug a screenshot reveals and a unit test misses.

Best For

Engineering teams shipping front-end changes with an agent in the loop who want real verification before merge.

Installation: /plugin install example-skills@anthropic-agent-skills

8. Supabase

The Supabase skill set teaches an agent to write schema and queries that follow Supabase’s own guidance instead of generic SQL that ignores how the platform works, which matters because database mistakes are expensive and agents make them confidently, especially around access control. It encodes Postgres best practices including row-level security, guides auth flows and schema design that match the platform, and comes from the Supabase team, so it reflects current recommendations rather than stale tutorials.

Best For

Teams running Supabase or Postgres who want safe, idiomatic database work from their agents.

Installation: npx skills add supabase/agent-skills

9. Internal-comms

Internal-comms is Anthropic’s skill for writing internal communications in the formats a company already uses, so the agent stops rebuilding the same structure from scratch every time. It handles status reports, leadership updates, and company newsletters, covers FAQs, incident reports, and project updates in consistent formats, and reuses the formats your company already prefers rather than inventing new ones each draft.

Best For

Operations, comms, and team leads who write the same kinds of updates on a weekly cycle.

Installation: /plugin install example-skills@anthropic-agent-skills

10. Corey Haines marketing skills

Corey Haines marketing skills are a SaaS marketer’s own collection of methods for CRO, copywriting, SEO, and growth work, built by Corey Haines to replace “write something good” with an actual process for each task. The collection runs structured SEO audits and programmatic SEO planning, treats copywriting, copy editing, and content strategy as distinct methods, and adds marketing psychology and AI-SEO approaches aimed at answer engines. For a content or growth team, it is the closest thing to handing the agent a marketing playbook.

Best For

Marketing and content teams running SEO, copy, and strategy work through their agents.

Installation: npx skills add coreyhaines31/marketingskills

11. Doc-coauthoring

Doc-coauthoring is Anthropic’s skill for co-writing specs and long documents through a structured back-and-forth, instead of producing something confident and wrong in one shot. It draws out what it needs from you in stages before it drafts, then iterates the document section by section rather than one-shotting it. It also checks that the finished doc reads clearly for the audience it targets, so the result is a document built with you rather than guessed at.

Best For

Product managers, engineers, and founders writing specs, proposals, or decision docs that have to land with a specific reader.

Installation: /plugin install example-skills@anthropic-agent-skills

12. Superpowers

Superpowers is a skill collection that packages the discipline a senior engineer would apply, so an agent stops jumping straight to a fix and calling it done. It adds systematic debugging and test-driven development workflows, forces a written plan before code and a verification pass before “done,” and includes structured steps for requesting and receiving code review. It is less about new capabilities and more about making the agent work in a trustworthy order.

Best for

Engineering teams that want agents to follow a real process instead of improvising a fix.

Installation: npx skills add obra/superpowers

13. brand-guidelines and theme-factory

Brand-guidelines and theme-factory are two Anthropic skills that keep an agent’s visual output consistent across a project, since output otherwise looks different every run and reads as sloppy across a deck or a set of pages. brand-guidelines applies Anthropic’s official colors and typography and works as a template you fork for your own brand, while theme-factory ships 10 preset color-and-font themes and can generate a new one on the fly. Both apply across slides, docs, reports, and HTML pages, so a whole project shares one look.

Best For

Design and marketing teams that want every artifact to look like it came from the same place.

Installation: /plugin install example-skills@anthropic-agent-skills

14. Firecrawl

The Firecrawl skill gives an agent a clean way to crawl and scrape sites into structured, readable content, which matters because agents are only as good as the data you can get in front of them and raw web pages are messy. It turns pages into clean text instead of raw HTML, works across entire sites rather than the single URL you happen to paste, and comes from the Firecrawl team behind the underlying scraping engine, which makes it useful for research and competitive monitoring.

Best For

Data, research, and marketing teams that pull live content from the web into their workflows.

Installation: npx skills add firecrawl/cli

15. Claude-api

Claude-api is Anthropic’s own skill for Claude API and SDK reference material, covering documentation and best practices across multiple languages so an agent writes integration code against today’s SDK instead of last year’s. Models are confident about APIs they half-remember, and the Claude API moves faster than any training cutoff, which is exactly the gap this skill closes. It bundles with Claude Code, so generated integration code stays current and you skip a tedious round of correcting calls that no longer exist.

Best For

Developers building on the Claude API who are tired of fixing outdated SDK calls by hand.

Installation: /plugin install claude-api@anthropic-agent-skills

Agent skills vs MCP, and why you usually need both

People keep framing skills and MCP as rivals. They solve different problems.

A skill is knowledge. It teaches an agent how to approach a task using the tools it already has. MCP is connectivity. It gives an agent access to systems it cannot reach on its own, like your database, your email, or a third-party API.

Anthropic frames it with a hardware store analogy. MCP is access to the aisles. A skill is the employee who walks you through the repair and shows you the right technique.

A useful rule of thumb came out of the practitioner debate in early 2026. If the data changes between runs and the agent needs live access, you want MCP. If the knowledge is stable enough to write down once and stay correct for weeks, a skill file is simpler and cheaper. When you need both, the skill defines the method and MCP fetches the live data the method works on.

Skills and MCP fit together for exactly this reason. One teaches, the other connects. A “comparable company analysis” skill can define which metrics to pull and how to format the output, while MCP servers supply the financial data. And when you are ready to give your agent live tool access, you can connect Claude to your tools through MCP360, a unified gateway that links agents to 100+ tools through a single endpoint.

How to add or build your own agent skill

Installing an existing skill is the quick win. Building your own is where the real extension happens. Here is the path for both.

Step 1. Install a ready-made skill

On a paid Claude.ai plan, the official example skills are already available, so you can ask for one by name. In Claude Code, add Anthropic’s repository as a plugin marketplace once, then install whichever bundle you want.

/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills
/plugin install example-skills@anthropic-agent-skills
/plugin install claude-api@anthropic-agent-skills

For any other skill, or any other agent like Cursor or Codex, the skills.sh installer is the one command that works everywhere. Through the Claude API, you upload skills with the Skills API instead.

npx skills add anthropics/skills
npx skills add vercel-labs/agent-skills

Step 2. Find the gap worth filling

Before writing a custom skill, run your agent on a few real tasks and watch where it struggles or where you keep correcting it. That repeated correction is the skill you should write.

Step 3. Create the skill folder and SKILL.md

Make a folder and add a SKILL.md file. The frontmatter needs only a name and a description. Write the description carefully, because the agent uses it to decide when to trigger the skill.

---
name: pr-writer
description: Writes pull request titles and descriptions from staged git changes. Use when the user asks to open or draft a pull request.
---
# PR Writer
When the user asks for a pull request:
1. Run `git diff --staged` to read the staged changes.
2. Summarize what changed and why in plain language.
3. Output a title under 70 characters, then a description with Summary, Changes, and Testing sections.
## Guidelines
- Keep the title in imperative mood, for example "Add retry logic to the upload queue".
- Never invent changes that are not in the diff.

Step 4. Keep it lean and split as it grows

When the SKILL.md gets long, move the rarely used parts into separate reference files and point to them from the main file. The agent reads those only when the task needs them, which keeps the core skill small.

Step 5. Test, then iterate with the agent

Run the skill on real tasks. When it goes off track, ask the agent to reflect on what it misread, then tighten the wording. A skill gets good through a few rounds of this, not in one draft.

Frequently Asked Questions

Conclusion

The catalog is the easy part. Anyone can install the document skills or pull a Vercel set off skills.sh. What separates the teams that get real value is what they do after that. They take the procedures their agents get wrong, the corrections they make by hand every day, and commit them as versioned skills the whole organization runs.

That is the actual promise of the format. The win is encoding how your team works into something an agent applies the same way every time and a colleague can review like code, which goes well past producing a cleaner slide deck. The open standard makes the investment durable, so a skill written well this year keeps paying off as the tools underneath it change.

Skills reward teams that treat their own expertise as an asset worth packaging. Take the one workflow you explain to your agent most often, build that skill first, put it under version control, and require the rest of your team to use it. That is where a general-purpose agent becomes your agent.