Before the seven topics, take a look at the path that connects everything: you write a workflow in Markdown, it starts living in a folder (.claude/skills), and the agent exposes it as a slash command that it can call when you (or an instruction) invoke it. A skill is essentially a reusable piece of process.

Illustrative diagram — a skill starts as a workflow described in text; once saved, the agent offers it as a command and reuses it consistently whenever invoked.

What it is

A skill is, in essence, a instruction markdown file — conceptually identical to the layer W (workflows) of the framework WAT. The difference from a workflow you only describe in chat is where it lives e how it’s triggered: the skill is saved in a project folder and invoked with a command, so it can be run the same way as many times as you like, without you having to rewrite the process.

The liberating detail: you don’t need to know how to write skills. You describe the workflow in natural language—"every time I ask, do X, then Y, then save to Z"—and ask the agent to turn this into a skill / slash command. It creates the file, and then you can call it with a command. It’s the same principle as vibe coding: describe the result, and AI does the heavy lifting.

Why learn

Transforme este workflow numa skill chamável (slash command).

Nome desejado: <nome-da-skill>
Quando deve ser usada: <descreva o gatilho — ex.: "quando eu pedir um resumo de reunião">
Argumentos que ela recebe: <ex.: texto-bruto, formato-de-saida>
Passos do processo:
1. <passo 1>
2. <passo 2>
3. <onde salvar / formato final>

Crie o arquivo em .claude/skills/ e me diga como invocá-la.

Key concepts

What it is

Skills live in a project directory called .claude/skills. The organization is simple: each skill has its own folder, and inside it is a skill file that describes what it does. The agent scans that folder and exposes each skill as a slash command — a command that starts with / and what you type to trigger it.

Why learn

Understanding the place and the mechanism demystifies it: a skill isn’t a hidden AI feature, it’s a file in a folder that becomes a command. Note the recent unification: slash commands have been unified into skills — in other words, creating a skill and creating a slash command have become the same thing. That’s why comparing them with built-ins like /clear help: the only difference is that yours are defined by you, in the project.

Lifecycle of a skill

Key concepts

What it is

Every skill has four essential parts: name (how it's called), description (o trigger — teaches the agent WHEN use the skill), expected arguments (the inputs it receives) and the step-by-step instructions (what to do). The most underrated piece is the description: it isn’t decorative—it’s what lets the agent decide on its own that this is the right skill for the situation.

---
name: <nome-da-skill>
description: <quando-acionar — ex.: rascunhar um e-mail a partir de bullets>
---

# <Título da skill>

## Argumentos
- destinatario: <quem recebe>
- tom: <profissional | casual>
- bullets: <pontos-chave do e-mail>

## Passos
1. Leia os <bullets> e o <tom>.
2. Escreva um e-mail polido, conciso, sem enrolação.
3. Salve em temporary/<nome-arquivo>.md

Why learn

Understanding the anatomy gives you control even without writing code: you know how to request a good trigger description (“use when I paste email bullets”), name clear arguments, and list steps in the right order. And you know how to review what the agent generated—if the description is weak, just ask it to make it more specific. The structure frontmatter (name + description) + body (arguments + steps) is the skeleton of every skill.

Key concepts

What it is

A skill doesn’t replace the tools (tools) — it orchestrates. Within your steps, a skill can still trigger tools: Python scripts that search the web, scrape a page, or generate a document. In other words, the WAT remains intact underneath: the skill is the W (workflow), the tool is the T (tool), and the agent decides when to run each tool during the process.

Why learn

Knowing that skill ≈ W and tool ≈ T avoids a common confusion: thinking that adopting skills throws away everything you’ve learned about tools and MCP. It doesn’t. A skill simply gives you a outline reusable guide to when and how to use your tools. A "market research" skill, for example, might say: search the web, scrape the first three pages, summarize them, and generate a document — calling a tool at each step.

Key concepts

What it is

Not everything deserves to become a skill. The rule: create a skill when the process repeats, consistency matters, the instructions are complex or easy to forget, or you want to share it with the team. For everything else—a one-sentence task, an initial experiment, a simple instruction—it’s faster to just type. Packaging a trivial task into a skill only adds ceremony.

Why learn

The criteria avoid both extremes: never using skills (and re-explaining everything every time) or turning anything into a skill (and cluttering the folder with commands you use only once). The key question is simple: "will I repeat this?" If so, and consistency matters, a skill is worthwhile. If it’s a one-off, type it.

Key concepts

What it is

The division of labor: the CLAUDE.md stores only what applies to every session — the project's purpose, goal, framework, general rules. It is always in context. What is task-based (per-task) goes to skills, which carry on demand — only when you invoke that command. It’s the difference between “what the AI always needs to know” and “what it only needs when doing X.”

Illustrative diagram — putting everything in CLAUDE.md fills up the fixed context; keeping per-task instructions in skills makes dozens of commands available without adding weight, because only the one you invoke is loaded.

Why learn

The classic beginner mistake is put everything in CLAUDE.md — every instruction, every workflow, every detail. This exceeds the context: the file gets huge, takes up space in every session, and degrades the AI’s attention. That’s exactly the point of skills: you can have 20, 50 skills without making anything bloated, because they only load when called. A concise CLAUDE.md + many on-demand skills > a giant CLAUDE.md.

Key concepts

What it is

Since a skill is just a file in a folder of the project, it inherits all the advantages of a code file: it can be versioned in Git (change history, review, rollback), and shared with anyone who clones the project. The process stops being knowledge trapped in one person’s head and becomes a team asset.

Why learn

This is the leap from "personal trick" to "team capability." When your best workflow becomes a versioned skill, any colleague can run the same process, with the same quality, without having to ask you how. Fixes to the skill benefit everyone the next time it's invoked. This is real reuse: write it once, and the whole team benefits.

Key concepts