Tired of re-explaining your process to Claude Code? Turn it into a skill!
Have you ever found yourself in a situation where you had to repeat instructions to an AI agent several times?
Nowadays, AI has evolved to the point where it can help us in our jobs or daily lives. However, there are still several challenges to overcome. One is explaining to an agent the work process we already follow and feel comfortable with. Another is the cost of letting AI know the instructions for periodic tasks, measured not only in tokens but also in our own time and effort.
For these situations Skills can help us. They turn the AI into a specialist: we teach it our own process and define in advance the instructions it should follow to face specific situations.
In this post, we’ll explore what skills are, why they matter, how to create them, and walk through some practical examples.
Why Claude Code Skills Matter
By default, Claude Code is a general-purpose AI. It knows a little about almost everything, but nothing about how you work. Skills change that. A skill packages your instructions, steps, workflow into something that Claude can load whenever a task needs it. This turns a general-purpose AI into a specialist that follows a clear and defined process.
Without skills, every new conversation starts from scratch. You have to type the same long instructions and explain the same context. This wastes tokens, as well as your time and energy. With a skill, however, you write the process once and can reuse it every time you need it.
Why not just paste the instructions into chat?
When the agent receives clear and well-defined instructions, the results improve and the model makes fewer mistakes. In other words, it stops guessing and the output becomes more consistent, useful for tasks for which you want to define specific workflows. The following table shows how a skill is loaded. Basically, when a skill is not needed, the agent only knows the title and a short description of it.
Stage | When it loads | Cost | Contents |
|---|---|---|---|
Metadata | Always, at session start | ~100 tokens per skill | name + description only |
Body | When the skill triggers | Keep under ~5k tokens | The SKILL.md instructions |
Bundled files | Only when read/run | Zero until touched | Reference docs, scripts |
Anatomy of a Skill

Think of a skill as the on-boarding doc you'd write for a new teammate, except an AI agent reads it when it becomes relevant. In practice, a skill is just a text file that contains a short description of its purpose, an explanation of when it should be used, and the steps, procedures, and even tools the AI should use to solve specific problems.
Minimum viable skill:
my-skill/
└── SKILL.md
Complete skill:
my-skill/
├── SKILL.md
├── scripts/
│ └── helper.py
├── references/
│ └── guide.md
└── assets/
└── template.docx
How to install Skills?
Before installing our first skill, it is important to understand the different levels at which skills can be installed.
Personal skills are stored on your PC (~/.claude/skills/). These can be useful for tasks for which you want to define specific workflows, e.g. workflows you want in every project, just for you.
Project skills are added to the repository's (.claude/skills/). These ones can be shared with other team members. These are preferred when you want all team members to work with the same process and get consistent results.
Now let’s check some ways we can find and install skills.
Manual installation
The simplest way to install a skill is to create a folder with the SKILL.md file, and paste the content of your skill into it. For example, Anthropic has a repository with some examples:
Step 1. Create skills folder: in case you don't have it, you can run the following command
mkdir -p .claude/skills/
Step 2. Create a folder with the name of the skill we want to install:
In this example, we will use
cd .claude/skills
mkdir frontend-design
touch frontend-design/SKILL.md
Step 3. Copy and paste the content of the skill in the file we just created

Step 4. Verify Claude detects the new skill
In your console run the following commands:
claude
/skills

Claude Marketplace
We can install skills from the Plugins section in the Claude CLI. It is important to mention the difference between a skill and a plugin: a skill is designed for a specific purpose, whereas a plugin is a package that can be installed and may contain several skills, agents, hooks and an MCP server.
As an example, we installed Superpowers from the marketplace:
Step 1. Open the Claude console and go to the Plugins section
claude
/plugin
You should see something similar to the following submenu:

Step 2. Type “superpowers” in the search bar

Superpowers is an open-source Claude Code plugin by Jesse Vincent (obra). It gives Claude a structured development workflow: brainstorming and planning before coding, test-driven development, systematic debugging, and subagent-driven execution with built-in code review. It also teaches Claude how to write and test new skills.
You can install this plugin by selecting it with the arrow key and pressing the Enter button.

Claude Code confirms the installation:

You can explore some interesting skills at the following link:
Create your own skill
Installing existing skills is useful, but the main benefit comes from writing your own. A good candidate for a skill is any task you repeat often and always explain the same way. Keep in mind: if you keep pasting the same instructions, checklist, or procedure into Claude, that's a skill.
A good example is commit messages. Every team has its own convention; we will create a skill to follow the conventions described on
Step 1. Create the skill folder
Since we want the whole team to use the same convention, we’ll create it as a project skill:
mkdir -p .claude/skills/commit-message
touch .claude/skills/commit-message/SKILL.md
Your structure should look like this:

Step 2. Write the front matter (Metadata)
Every skill starts with front matter, a small metadata block at the top of the file. It has two fields:
name: the skill identifier.
description: what the skill does and when Claude should use it.
The description is the most important part of the skill. Remember that at session start, Claude only reads the name and description of each skill, so this is what it uses to decide whether to load the skill.
---
name: commit-message
description: Writes git commit messages following our Conventional Commits convention. Use when the user asks to commit, create a commit, write a commit message, or save their changes to git.
---
Step 3. Write the instructions
Below the metadata, write the process step by step, you can use the same words to explain it to a new teammate. Paste the complete content into SKILL.md:
---
name: commit-message
description: Writes git commit messages following our Conventional Commits convention. Use when the user asks to commit, create a commit, write a commit message, or save their changes to git.
---
# Commit Message
## Process
1. Run `git status` and `git diff --staged` to see the staged changes.
If nothing is staged, ask the user which files to include. Do not stage everything automatically.
2. Run `git branch --show-current` to get the branch name.
If it contains a ticket ID (e.g. `feature/PROJ-123-login`), use it in the message.
3. Write the commit message following the format below.
4. Show the message to the user and ask for confirmation before running `git commit`.
## Format
```
<type>(<scope>): <short summary>
<body: what changed and why>
Refs: <TICKET-ID>
```
## Rules
- **type** must be one of: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`.
- **scope** is the module or area affected (e.g. `auth`, `api`, `ui`). Optional.
- **summary**: imperative mood ("add", not "added"), lowercase, no period, max 50 characters.
- **body**: explain *why* the change was made, not just *what*. Wrap lines at 72 characters.
- Omit the `Refs` line if there's no ticket ID in the branch name.
- If the changes are unrelated to each other, suggest splitting them into separate commits.
## Example
```
feat(auth): add password reset via email
Users had no way to recover their account without contacting
support. This adds a reset link that expires after 30 minutes.
Refs: PROJ-123
```
Step 4. Verify Claude detects the new skill
run the next commands
claude
/skills
You should see commit-message in the list of project skills.

Step 5. Test it
To test the skill, we used it to commit the skill itself:
git add .
Then ask Claude:
commit my changes
Claude should load the skill automatically, read the diff, detect the ticket from the branch name (if one exists), and suggest a message in the right format before committing.


You can also call the skill directly by its name:
/commit-message
Conclusion
Using a Claude Code skill is the best way to get stable results if you have a solid and well-defined process in place. The AI doesn't need to understand your entire workflow; it just needs the right prompt at the right time. Pay attention to the description: if it’s too vague, the skill won't be triggered; if it's too broad, the skill will run when you don't want it to. Update them as your team's workflow changes. Also, be careful which skills you use, and always check them for malicious scripts before installing.
Resources
Claude Code Skills documentation anthropics/skills: example skills from Anthropic Claude plugin directory skills.sh: community skills Conventional Commits 1.0.0













