Skills for Claude Code: what they are, how to install them, where to find ready ones

Skills for Claude Code: what they are, how to install them, where to find ready ones

A skill is a folder with one file in it describing how a particular task should be done. The agent loads it by itself when the task matches.

A skill is a folder with one file in it describing how a particular task should be done. The agent loads it by itself when the task matches.

Put simply: you describe a procedure once, and from then on the agent follows it instead of improvising from scratch every time.

Below: how a skill differs from a prompt, three ways to install a ready one, how to write your own in five minutes, what to check in somebody else's skill, what this pays, and where to find vetted ones — the catalogue holds over nine thousand with open descriptions.

This is a living guide: the daily AI digests keep it current with new releases.

---

The short version

A skill is not a prompt, it is a file holding a procedure. A prompt lives once; a skill gets picked up automatically whenever the task fits.

It installs in a minute: a folder containing a `SKILL.md` file goes in the right place and the agent sees it.

It takes five minutes to write. There is essentially one required field — the description that tells the agent when to use it.

It does not eat context. Only a short label stays in the agent's memory permanently; the procedure itself loads at the moment it fires.

Read somebody else's skill before installing it, the way you would read somebody else's script: it can run commands.

If you don't know which skill you need, the Cerebrum section breaks the task into five to seven steps and assembles the chain itself from a base of over nine thousand skills.

There is money here. A finished commercial proposal built through such a chain takes 5–7 minutes; the $1 900 proposal from a real deal was built exactly this way.

---

Part 1. What a skill is

A skill is a way of packing a repeating instruction into a file the agent loads only when it is needed.

Per the official Claude Code documentation, creating a `SKILL.md` file with instructions is enough — Claude adds it to its set.

When to make one. If you keep pasting the same multi-step procedure into the chat. Or if a section of your project description has grown from a couple of facts into a full instruction.

How it is built. A short settings block at the top, ordinary text with instructions below. Of the settings, essentially one line is required: the description, which the agent uses to decide when to switch the skill on. The command name comes from the folder name.

Skills run on the open Agent Skills standard, which Anthropic introduced in late 2025. Within months it had been picked up by Cursor, Codex, Gemini CLI and dozens of other environments.

How a skill differs from a prompt, MCP and a subagent

Four things that constantly get confused. The difference is in purpose:

A prompt is one-off request text. It is gone in the next session. A skill lives as a file and gets picked up on its own.

The project description file (`CLAUDE.md`) holds permanent facts that are always in the agent's memory. A skill is a procedure loaded on demand. That is why bulky checklists get moved out of the project description into a skill, so as not to burn memory for nothing.

MCP is the standard for connecting external tools: databases, services, storage. A skill is the knowledge of what to do with those tools. They do not compete: a skill can describe how to use MCP tools properly.

A subagent is a separate instance of an agent with its own memory for a subtask. A skill can be run inside such an instance, but a skill in itself is an instruction, not a second agent.

In practice they stack into one setup. Permanent facts about the project live in the description, access to services comes from MCP, the knowledge of how to do it right is packed into a skill, and the heavy autonomous part gets handed off by the skill to a separate instance when needed.

So the question "skill or MCP" is put wrongly: they are different layers and they work together.

How the agent knows when to use a skill

By the description. In an ordinary session the agent sees only the short labels of every available skill — cheap, on the order of a hundred words each. The full procedure is pulled in only at the moment the skill fires.

Hence the main rule: the description must state plainly what the skill does and when to apply it. Not "working with text" but "use when the user asks to review a diff or write a commit message". This is the one field Anthropic recommends always filling in.

The second route is manual: type `/` and the skill name. Useful for procedures you want to keep under control: long checks, deployment, report generation. Some skills the agent switches on itself, some run only on a direct call — so that time and money are not spent without your say-so.

---

Part 2. How to install one

Three ways. All of them come down to the same thing: a `SKILL.md` file ending up in a folder the agent reads.

By hand

Create the skill folder in one of the places Claude Code looks:

Personal — `~/.claude/skills/<name>/SKILL.md`, available across all your projects.

Project — `.claude/skills/<name>/SKILL.md`, only in that repository. Handy to commit so the whole team gets the same set.

From a plugin — wherever the plugin is enabled.

When names clash, the enterprise level overrides the personal one and the personal overrides the project one. Claude Code watches the folders and picks up changes inside the current session, without a restart.

A file downloaded from the catalogue simply needs unpacking into `.claude/skills/<name>/` — the agent will see it on the next matching task.

A subtlety with large repositories. Project skills load from the starting folder and every parent folder up to the root, while nested ones are connected the moment the agent first touches a file inside that subfolder. This lets a separate package carry its own set that switches on exactly when you are working on it.

From a marketplace

Install the skill as part of a plugin. The official marketplace is added with `/plugin marketplace add anthropics/claude-plugins-official`, after which a plugin installs like this: `/plugin install skill-creator@claude-plugins-official`.

Plugins are convenient because alongside skills they bring agents, hooks and service connections in one package.

By command from a catalogue

Many catalogues give you a ready install line of the form `npx skills add <owner>/<repo> --skill <name> --agent claude-code`. It drops the file into the project folder.

How to check it worked

Type `/` and the skill's folder name. If it appears in the suggestions, the agent has read it.

Second test: ask something matching the description. The agent should offer or carry out the procedure by itself.

If it does not appear, check the folder is in the right place, that it contains a file called exactly `SKILL.md`, and that the settings hold a clear description.

Skills across a team

Project skills are how you hand everyone the same set of procedures: put the folder in the repository, commit it, and everyone who clones the project gets the same commands.

Handy for shared review, deployment and code-generation rules: no need to circulate instructions in chat, they travel with the code. Updates reach the team with an ordinary `git pull`.

---

Part 3. How to write your own

In five minutes. Create a folder and put a `SKILL.md` in it with a description and instructions.

The minimal working example from the documentation:

```

---

description: Summarises uncommitted changes and highlights risks. Use when the user asks what changed, wants a commit message, or asks to review their diff.

---

Current changes

!`git diff HEAD`

Instructions

Summarise the changes above in two or three points, then list the risks: missing error handling, hardcoded values, tests that need updating. If the diff is empty, say so.

```

The line `` !`git diff HEAD` `` is a live data substitution: Claude Code runs the command and replaces the line with its output before the agent reads the skill. The instructions arrive with the current content already in them.

What it consists of

A skill is a folder with `SKILL.md` as the entry point; templates, examples and scripts can sit alongside it. The permitted settings are `name`, `description`, `license`, `compatibility`, `metadata` and `allowed-tools` — all optional, with only the description genuinely required.

The description is both the label and the trigger. Write what the skill does and when to apply it, in the words a person would use to ask.

The body is the procedure itself: a step-by-step checklist, not abstract wishes. A short, checkable body works more reliably than a long argument.

Scripts and templates — move repeatable mechanics into separate files the body refers to, so the size stays down. They load only when actually needed.

Why structure works better here than phrasing

A skill is structured text, and that is no accident.

Claude is trained to read markup as structural boundaries. In plain terms: if you mark parts of a request as separate blocks, it understands where the instruction ends and the material begins, where an example sits, and where the requirements for the output are.

That is exactly why a skill with a clean split into description, body and separated files works more reliably than one written as a wall of text — even with identical content.

And the same holds beyond skills. The technique applies to any working request: break it into blocks and you get a different class of answer. It shows up most on long documents, where the instruction usually dissolves into the material.

The express course "Claude: from your first prompt to your own library of mega-capabilities" is entirely about this: how this model differs from the rest, structured prompts with markup for business tasks, and twelve ready mega-prompts for working scenarios.

It is useful precisely as the foundation under skills: understanding why structure works, you write a skill body deliberately instead of copying somebody's template.

$9, included in the Creator plan alongside the main programme. Not included in the three free days of Basic.

It gets written in iterations

A good skill never comes out right first time. The working cycle: write a minimal version → call it on a real task → see where the agent went astray → adjust the description or a step.

The official marketplace provides a tool for this — the `skill-creator` plugin, which helps generate and calibrate descriptions.

Editing as you go is easy: Claude Code sees changes in the current session, so you save the file and the next call already uses the new version.

Before writing your own, look at the advanced ones

Worth mentioning a part of the catalogue people usually do not know about.

Alongside skills gathered from open repositories, the section holds more than 1 200 advanced skills written by the platform's own authors. Not repackaged work from elsewhere but procedures for specific vibe-coding tasks — the ones that normally take weeks to put together.

What they cover by technology:

Payments — Stripe: subscriptions, one-off payments, billing.

Mobile — Android in the native and modern stack, iOS on Swift and across the Apple ecosystem.

Mini apps — the WeChat Mini Programs ecosystem, front end and back end.

Desktop — Electron, Qt and C++.

Browser extensions — the Chrome Extension API.

Web3 — Solidity and smart contracts.

What gets built with them end to end:

The practical conclusion. Before writing a procedure from scratch, check: one for your task may already exist, written by somebody who was not doing it for the first time. You write your own when there genuinely is nothing ready.

Access: cards and descriptions are open to everyone. Ordinary skill files come with Basic, advanced ones with Creator+, or as a one-off for $9, or for 1 000 XP points.

Three common mistakes

A vague description. The agent does not understand when to call the skill and it "doesn't fire". The most frequent problem by far.

A wall-of-text body. The longer and more abstract the instruction, the more often the model prefers its own route.

Permanent facts inside a skill. Those belong in the project description. Keep skills for procedures.

If a skill seems to stop having any effect after the first answer, the content is usually fine and the model is simply choosing other tools. Strengthen the description, or call the skill again after the context has been compacted.

---

Part 4. What to check in somebody else's skill

Somebody else's skill is executable instructions for your agent. Read it in full, the way you read somebody else's script.

Commands in the body. Lines of the form `` !`...` `` run before the agent reads the skill. Make sure they hold something harmless like `git diff` and not a download-and-run from the internet.

Requested permissions. A skill can ask for access to tools. Do not grant extended rights to something whose task does not need them.

Scripts in the folder. If separate files sit alongside, read them: the body can launch them without asking separately.

Provenance. Prefer skills with a clear origin. In the catalogue the description is visible before download, which lets you judge a skill before the file is on your machine.

---

Part 5. Where to get ready ones

The Skills for Claude Code catalogue — over nine thousand skills with open descriptions. Every one has a card at its own address; files download with a subscription.

Descriptions are open to guests — you can study what a skill does before registering at all. The catalogue is topped up by daily radars, so fresh finds appear without manual curation.

Why this beats a list of GitHub links: every skill has a card with a clear description and a category, rather than a bare link to a repository that may have moved in a month.

How to search properly

Skills are organised by task: engineering and code review, working with documents, content generation, analytics, marketing, operations and others.

Search from your task, not from a ranking. A skill is worth exactly as much as its description matches what you actually do. A skill with an accurate description will fire reliably; a fashionable one unrelated to your work simply will not.

Where to start. The easiest entry is the free first-party content generation skills — there are twenty of them, they need no key configuration, and they demonstrate the mechanic of a skill walking an agent through steps. Available to any signed-in user.

Then move to your own stack: code review, document work, analytics.

---

Part 6. If you don't know which skill you need

An honest problem with a catalogue of over nine thousand entries: to pick the right one you have to roughly know what you are looking for. And a complex task is usually solved not by one skill but by several in sequence — and exactly which ones is not something an outsider knows.

There is a separate section for this — Cerebrum.

What it does

You describe the task in ordinary words. Not "find me a skill for Stripe" but "I want a service with subscriptions and a user account area".

From there it:

Asks if the task is vague. One or two questions to the point: what you already use, where the data comes from, what the output should be. Not a form but the bare minimum without which any selection would be guesswork.

Searches by meaning, not by keyword. One query across two bases at once: over nine thousand skills and more than 600 deployment-ready open-source projects. A phrasing like "I need emails to sort themselves into folders" finds the right thing even if those words appear nowhere in the tool's description.

Assembles one chain rather than a list of options. The task is broken into five to seven steps in running order: step one, this skill, its role and what it passes on; step two, the next one, and so on to the result. One entry per step, no "here are twenty options, work it out".

Explains the joins. For each step, how to get it and how to connect it to its neighbour. For open-source parts it produces a ready prompt for Claude Code: what to clone, what to read, what to build, what to adapt. Copy, paste, go.

Tells you which step to start today. Not "good luck" but a specific first point of entry.

Why a chain and not a list

A list of tools anyone can find. The problem is always elsewhere: what connects to what, in what order, and what hands off to whom.

Skills and open-source projects also mix inside one chain according to the task rather than the catalogue's sections: in one case step one is a skill for Claude Code and step two a service you deploy yourself. In another it is the reverse.

Three things that are non-negotiable here

Links only to entries that actually exist. Cerebrum works from what the base search returned and does not invent projects and skills that are not there — that is written into its rules.

Deployment methods are never invented. If a project's description does not say how to stand it up, it says so and points you to the README, instead of a plausible fabrication.

Nothing unsuitable gets mentioned. The answer is not padded for the sake of length.

What it costs

Three levels, chosen right in the input field according to the difficulty of the task.

| Level | For what | Ceiling per turn |

|---|---|---|

| light | selection, short tasks | up to $0.60 |

| medium | complex chains | up to $1.00 |

| high | the hardest tasks | up to $2.00 |

The ceiling is not the price. It is the upper bound reserved at the start; after the answer the actual spend is calculated and the difference returns to your balance automatically. A typical turn costs noticeably less than the ceiling, and an empty answer means a full refund.

And a rule built into the behaviour: a paid tool never runs without your consent. The model and the price are named first, then it waits for confirmation.

Who it replaces the catalogue for

People who do not know what to search for. The task exists, the tool names do not.

People with a complex task. Five to seven steps cannot be assembled by hand out of over nine thousand entries.

People who do not want to work out the joins. A ready prompt for Claude Code removes most of the connecting work.

Who does not need it: if you know exactly which skill you want, open the catalogue directly, it is faster.

---

Part 7. What a skill actually gives you on a live task

Taken from something done in a real deal, so the difference between a prompt and a chain is visible.

The task

After a client call, a commercial proposal is needed. Not as text but as a finished deck that can be sent.

What came before

The recording of the call had been broken down: what the client said about their losses, what they fear, which lever matters most to them. Three pains, named by the client himself. That is the content of the future proposal — it is not invented.

How it was assembled

Step one. The sales assistant received the inputs and produced a detailed brief for the deck: style requirements, emphases, colours and fonts, number of slides, structure. And separately, which phrases to avoid. A list of prohibitions saves you from the clichés proposals usually fall apart on.

Step two. The same assistant checked its own answer against its own criteria. Plus a separate mode: the model took the role of the client and walked the deck slide by slide — where he would tense up, what he would skip. Then it made the corrections itself.

Step three. The finished brief went to Claude Code with the presentation skill. An editable file in 5–7 minutes.

Under ten minutes in total.

Why a skill and not a prompt

The presentation skill is not one request but a chain of roles: a copywriter writes the text → a designer sets the visual → the next one lays it out across slides → the final one checks the first three and delivers the result.

Four steps instead of one. And the fourth is the one that never happens in manual work: nobody checks their own draft against criteria.

What matters here

Not the speed. Ten minutes is a pleasant side effect. A proposal assembled in ten minutes out of something other than the client's own words is simply quickly made rubbish.

The order. Break down the conversation → brief → check → assemble. Each step eats the result of the previous one, and what comes out is a document the client recognises himself in.

This proposal was paid in full — $1 900 for a one-year system. The client is Zakhar Fomin, owner of a dental clinic, who gave permission to use his name and the figures.

---

Part 8. How people earn from this

The catalogue on its own is a warehouse. Nobody buys a warehouse.

The industry bundle

What people buy: a selection made for a specific profession. Ten or fifteen skills "for a lawyer", "for a marketplace seller", "for a clinic", tuned to that profession's processes and documents.

The client is not paying for files. They are paying for somebody having chosen, configured and explained how to use them.

Why it works. A person opening a catalogue of nine thousand entries for the first time closes it within ten minutes. The same person handed a folder of twelve labelled "these are for your work" starts using them the same day.

You are selling a decision taken off their hands, not files.

The price range

From a scrape of 848 job listings over 24 days: a system or pipeline runs $490–1 460, against a median one-off job of $30–75.

An honest caveat: an explicit budget appears in 6% of listings, with two to fifteen observations per category.

The second way — your own projects, faster

A proposal in ten minutes instead of an evening. A deck, a report, a document from a template. This is not about selling a service but about getting more done in the same day.

The limits

A skill does not replace substance. The neatest chain will assemble a beautiful nothing if you do not know what your client is afraid of. Breaking down the conversation is a required part and it does not automate.

Results get verified. Figures, names and links are checked against sources. A skill speeds up production, it does not remove responsibility.

Not everything is worth automating. A task done once a quarter will not repay the selection and setup.

---

Part 9. What to open up for your task

Skills for Claude Code. Over nine thousand. Cards and descriptions open to everyone without registration. Files come with Basic. Advanced ones with Creator+, or as a one-off for $9, or for 1 000 XP points earned by working on the platform.

Ready-made assistants — the part that supplies substance. More than 140 across 14 categories. A skill assembles the document, but the brief for it is formulated by an assistant. The cycle described above needs two: the sales assistant — call breakdown, brief, the check-it-through-the-client's-eyes mode — and one specialised in your field. Plan: Basic.

Freelance 2.0 — if you need the whole system. 62 prompts across 11 funnel stages: research, positioning, content, lead magnets, social, monetisation, websites, funnels, sales with scripts and simulators. The key property is the same as a skill's: each result feeds the next. $9, included in Basic.

Cerebrum — if you do not know which skill you need. Describe the task in words, get a chain of five to seven steps with the joins explained and a ready prompt for Claude Code. Paid from your wallet on actual use, ceiling from $0.60 a turn.

Your own skills and assistants for your company — the Creator+ plan.

If Claude Code is still foreign territory

Skills are a tool for people already working with an agent in code. If you came here because you heard about Claude Code but do not write code, the order is different.

The course "Vibe coding: from zero to your own projects and money" takes you from nothing to your own projects. Three parts of it matter for this topic.

Module 1 — how an application is actually built. Explained through a restaurant: what the user sees, what runs underneath, how the database works, what an API is, why there is an admin panel, how logs and job queues work.

That is what a code-generation skill needs behind it, otherwise it stays a black box: you get a result and do not understand what you got.

Module 5 — Claude Code and bots. Applied work in the environment itself: bot structure, command logic, model integration.

The "Claude Code + Claude Design" block walks the environment end to end. That is the level at which skills stop being somebody else's files and become your working tool.

Plus something technical courses rarely include: module 3, eleven lessons, is not only about building websites but about selling them. Promoting your work, getting onto marketplaces, calculating response rates, bidding strategy. And module 6 is entirely about monetisation: niche, offer, landing page, funnel, revenue models.

The order is simple. If you do not understand what the agent built, start with the course. If you already work in Claude Code and want it to follow your procedure, skills and the Claude express course are enough.

Nearby: the automation templates section — more than 3 000 ready flows, if the task is mechanical; the AI agents hub — if what you need is a process rather than a document.

---

What comes next

The ecosystem moves fast: fresh releases and techniques are covered in the daily AI digests. If you work with open models, look into the Best open LLMs 2026 hub; if you want ready processes without code, automation templates.

The Skills for Claude Code catalogue is topped up daily.

---

FAQ

How does a skill differ from the project description?

The project description holds permanent facts that are always in the agent's memory. A skill is a procedure loaded only at the moment of use.

The practical rule from the documentation: if a section of the description has turned from a fact into a multi-step instruction, move it into a skill. A skill's body costs no memory until it is needed.

Do skills work in the web app and in Claude Code at the same time?

Yes: they are built on an open standard supported by different environments. The file format is one and the same. Claude Code adds its own extensions — call control, running in a separate instance, live data substitution — while the basic settings are identical everywhere.

What does using skills cost?

The mechanism itself is free — they are files your agent reads.

In the catalogue every skill's description is open for free and file downloads open with a subscription; twenty first-party content generation skills are free to any signed-in user.

In terms of model spend a skill is economical: only a short description sits in memory permanently, and the procedure loads only when it fires.

How many skills can be connected at once?

There is no hard limit: only short descriptions are held in memory, so a large set costs little, and only the one that fired gets unfolded.

In practice the constraint is not the number of skills but the quality of the descriptions: the more precise the description, the more reliably the agent picks the right one from many.

How do I update an installed skill?

Replace the files in its folder. Claude Code watches folders and picks up changes within the current session, without a restart.

If you created a completely new skills folder that did not exist when the session started, then restart the session.

Can a skill be run in isolation?

Yes: add `context: fork` to the settings and the skill runs in a separate instance with its own memory — the body becomes the instruction guiding it, and your conversation history is not passed along.

Useful for long autonomous tasks such as research that should not clutter the main conversation. By default such a skill runs in the background and the result comes back when it finishes.

Can you earn money from skills?

Yes, but what sells is the selection and the setup, not the file. An industry bundle for a specific profession — ten to fifteen skills tuned to its processes — is a complete service.

From the scrape of 848 listings, a system or pipeline runs $490–1 460 against a median one-off job of $30–75. The client pays for a decision taken off their hands: they will not pick from nine thousand entries themselves.

---

Try it

Registration is free and opens three days of full Basic access — the skill files, all 140+ assistants, the prompt texts, the ten-lesson sales module and six foundational courses including Freelance 2.0.

One thing to do right now. Take a document you produce regularly and always slowly: a proposal, a report, a deck. Find a skill in the catalogue for that type and run it once on a real task.

Watch not the speed but what your manual version usually lacked. Normally it is the final check against criteria — the step nobody ever performs on their own work.

What to read next

How Claude differs from other models — why structure beats phrasing.

What prompt engineering is — sixteen methods in four groups.

Six brief fields — what to supply so you do not get a template back.

One assistant against three — when a chain of roles works.

A commercial proposal in ten minutes — the full breakdown of assembling a deck.

What vibe coding is — if you came for Claude Code but do not write code.

App architecture as a building — so you understand what the agent built.

Why a project falls apart on the third edit — the spec as the source of truth.

What actually sells from vibe coding — eight formats with prices.

AI for developers — three ready helpers for the profession.

AI video generation — if your skill assembles visuals.

LLM pricing and token economics — what running a chain costs.