Skill
Skill Creator
Crédito: anthropics no GitHub (anthropics/skills) · 0 cópias
Indicada na UseIA por Cristiano Rochenbach Abreu em 5 de out. de 2026
179,8 mil estrelas no GitHubVer no GitHub
Tradução feita por IA. Em caso de dúvida, vale o texto original (aba “Original”).
---
name: skill-creator
description: Crie novas skills, modifique e melhore skills existentes e meça o desempenho de skills. Use quando o usuário quiser criar uma skill do zero, editar ou otimizar uma skill existente, rodar evals para testar uma skill, fazer benchmark do desempenho de uma skill com análise de variância ou otimizar a descrição de uma skill para acertar melhor quando ela deve ser acionada.
---
# Skill Creator
Uma skill para criar novas skills e melhorá-las de forma iterativa.
Em linhas gerais, o processo de criar uma skill é assim:
- Decida o que você quer que a skill faça e, mais ou menos, como ela deve fazer
- Escreva um rascunho da skill
- Crie alguns prompts de teste e rode o claude-com-acesso-à-skill neles
- Ajude o usuário a avaliar os resultados, de forma qualitativa e quantitativa
- Enquanto as execuções rodam em segundo plano, esboce alguns evals quantitativos, se ainda não houver (se já houver, você pode usá-los como estão ou modificá-los se achar que algo precisa mudar). Depois explique-os ao usuário (ou, se já existiam, explique os que já existem)
- Use o script `eval-viewer/generate_review.py` para mostrar os resultados ao usuário, para que ele os examine, e deixe-o ver também as métricas quantitativas
- Reescreva a skill com base no feedback da avaliação do usuário sobre os resultados (e também se houver falhas gritantes que apareçam nos benchmarks quantitativos)
- Repita até ficar satisfeito
- Amplie o conjunto de testes e tente de novo em escala maior
Seu trabalho ao usar esta skill é descobrir em que ponto do processo o usuário está e então entrar e ajudá-lo a avançar pelas etapas. Por exemplo, talvez ele diga "quero criar uma skill para X". Você pode ajudar a delimitar o que ele quer dizer, escrever um rascunho, escrever os casos de teste, descobrir como ele quer avaliar, rodar todos os prompts e repetir.
Por outro lado, talvez ele já tenha um rascunho da skill. Nesse caso, você pode ir direto para a parte de avaliar/iterar do ciclo.
Claro, você deve sempre ser flexível: se o usuário disser "não preciso rodar um monte de avaliações, só flua comigo", você pode fazer assim.
Depois que a skill estiver pronta (mas, de novo, a ordem é flexível), você também pode rodar o melhorador de descrição da skill, para o qual temos um script à parte, para otimizar o acionamento da skill.
Beleza? Beleza.
## Comunicação com o usuário
O skill creator pode ser usado por pessoas com níveis muito diferentes de familiaridade com o jargão de programação. Se você não ficou sabendo (e como ficaria, isso começou há muito pouco tempo), existe uma tendência em que o poder do Claude está inspirando encanadores a abrir o terminal e pais e avós a pesquisar "como instalar o npm". Por outro lado, a maior parte dos usuários provavelmente é bastante familiarizada com computadores.
Então preste atenção nas pistas de contexto para entender como formular a comunicação! No caso padrão, só para você ter uma ideia:
- "evaluation" e "benchmark" estão no limite, mas tudo bem
- para "JSON" e "assertion", espere sinais claros do usuário de que ele sabe o que são antes de usar os termos sem explicar
Tudo bem explicar termos brevemente se estiver em dúvida, e fique à vontade para esclarecer termos com uma definição curta se não tiver certeza de que o usuário vai entender.
---
## Criando uma skill
### Capture a intenção
Comece entendendo a intenção do usuário. A conversa atual pode já conter um fluxo de trabalho que o usuário quer capturar (por exemplo, ele diz "transforme isso em uma skill"). Se for o caso, extraia primeiro as respostas do histórico da conversa — as ferramentas usadas, a sequência de passos, as correções feitas pelo usuário, os formatos de entrada/saída observados. O usuário pode precisar preencher as lacunas e deve confirmar antes de seguir para o próximo passo.
1. O que esta skill deve permitir que o Claude faça?
2. Quando esta skill deve ser acionada? (quais frases/contextos do usuário)
3. Qual é o formato de saída esperado?
4. Devemos criar casos de teste para verificar se a skill funciona? Skills com saídas objetivamente verificáveis (transformações de arquivo, extração de dados, geração de código, passos fixos de fluxo de trabalho) se beneficiam de casos de teste. Skills com saídas subjetivas (estilo de escrita, arte) muitas vezes não precisam. Sugira o padrão adequado ao tipo de skill, mas deixe o usuário decidir.
### Entrevista e pesquisa
Pergunte de forma proativa sobre casos de borda, formatos de entrada/saída, arquivos de exemplo, critérios de sucesso e dependências. Espere para escrever os prompts de teste até ter essa parte bem resolvida.
Verifique os MCPs disponíveis — se forem úteis para pesquisa (buscar documentação, encontrar skills parecidas, consultar boas práticas), pesquise em paralelo por meio de subagentes, se houver, ou direto, caso contrário. Venha preparado com contexto para reduzir a carga sobre o usuário.
### Escreva o SKILL.md
Com base na entrevista com o usuário, preencha estes componentes:
- **name**: Identificador da skill
- **description**: Quando acionar e o que ela faz. Este é o principal mecanismo de acionamento — inclua tanto o que a skill faz QUANTO os contextos específicos em que usá-la. Toda a informação de "quando usar" vai aqui, não no corpo. Observação: atualmente o Claude tem tendência a "subacionar" skills — a não usá-las quando seriam úteis. Para combater isso, deixe as descrições das skills um pouco "insistentes". Por exemplo, em vez de "Como criar um dashboard simples e rápido para exibir dados internos da Anthropic.", você pode escrever "Como criar um dashboard simples e rápido para exibir dados internos da Anthropic. Use esta skill sempre que o usuário mencionar dashboards, visualização de dados, métricas internas ou quiser exibir qualquer tipo de dado da empresa, mesmo que não peça explicitamente um 'dashboard'."
- **compatibility**: Ferramentas e dependências necessárias (opcional, raramente necessário)
- **o resto da skill :)**
### Guia de escrita de skills
#### Anatomia de uma skill
```
skill-name/
├── SKILL.md (required)
│ ├── YAML frontmatter (name, description required)
│ └── Markdown instructions
└── Bundled Resources (optional)
├── scripts/ - Executable code for deterministic/repetitive tasks
├── references/ - Docs loaded into context as needed
└── assets/ - Files used in output (templates, icons, fonts)
```
#### Divulgação progressiva
As skills usam um sistema de carregamento em três níveis:
1. **Metadados** (name + description) - Sempre no contexto (~100 palavras)
2. **Corpo do SKILL.md** - No contexto sempre que a skill é acionada (idealmente <500 linhas)
3. **Recursos incluídos** - Conforme necessário (ilimitados; os scripts podem ser executados sem serem carregados)
Essas contagens de palavras são aproximadas e você pode se estender mais se precisar.
**Padrões principais:**
- Mantenha o SKILL.md com menos de 500 linhas; se estiver chegando perto desse limite, adicione uma camada extra de hierarquia, com indicações claras de para onde o modelo que usa a skill deve ir em seguida.
- Faça referência clara aos arquivos a partir do SKILL.md, com orientação sobre quando lê-los
- Para arquivos de referência grandes (>300 linhas), inclua um sumário
**Organização por domínio**: quando uma skill dá suporte a vários domínios/frameworks, organize por variante:
```
cloud-deploy/
├── SKILL.md (workflow + selection)
└── references/
├── aws.md
├── gcp.md
└── azure.md
```
O Claude lê apenas o arquivo de referência relevante.
#### Princípio da ausência de surpresas
Nem precisaria dizer, mas as skills não podem conter malware, código de exploit nem qualquer conteúdo que possa comprometer a segurança do sistema. O conteúdo de uma skill não deve surpreender o usuário quanto à intenção, se ela for descrita. Não aceite pedidos para criar skills enganosas ou projetadas para facilitar acesso não autorizado, exfiltração de dados ou outras atividades maliciosas. Coisas como "faça o papel de um XYZ" são aceitáveis.
#### Padrões de escrita
Prefira o modo imperativo nas instruções.
**Definindo formatos de saída** - Você pode fazer assim:
```markdown
## Report structure
ALWAYS use this exact template:
# [Title]
## Executive summary
## Key findings
## Recommendations
```
**Padrão de exemplos** - É útil incluir exemplos. Você pode formatá-los assim (mas, se "Input" e "Output" aparecerem nos exemplos, talvez valha fugir um pouco do formato):
```markdown
## Commit message format
**Example 1:**
Input: Added user authentication with JWT tokens
Output: feat(auth): implement JWT-based authentication
```
### Estilo de escrita
Tente explicar ao modelo por que as coisas são importantes, em vez de usar DEVEs pesados e ultrapassados. Use teoria da mente e tente deixar a skill geral, não super restrita a exemplos específicos. Comece escrevendo um rascunho e depois olhe para ele com olhos novos e melhore.
### Casos de teste
Depois de escrever o rascunho da skill, pense em 2 ou 3 prompts de teste realistas — o tipo de coisa que um usuário de verdade diria. Compartilhe-os com o usuário: [você não precisa usar exatamente estas palavras] "Aqui estão alguns casos de teste que eu gostaria de tentar. Parecem certos, ou você quer adicionar mais?" Depois rode-os.
Salve os casos de teste em `evals/evals.json`. Não escreva as assertions ainda — apenas os prompts. Você vai esboçar as assertions no próximo passo, enquanto as execuções estão em andamento.
```json
{
"skill_name": "example-skill",
"evals": [
{
"id": 1,
"prompt": "User's task prompt",
"expected_output": "Description of expected result",
"files": []
}
]
}
```
Veja `references/schemas.md` para o esquema completo (incluindo o campo `assertions`, que você vai adicionar depois).
## Executando e avaliando os casos de teste
Esta seção é uma sequência contínua — não pare no meio. NÃO use `/skill-test` nem qualquer outra skill de testes.
Coloque os resultados em `<skill-name>-workspace/`, ao lado do diretório da skill. Dentro do workspace, organize os resultados por iteração (`iteration-1/`, `iteration-2/` etc.) e, dentro de cada uma, cada caso de teste ganha um diretório (`eval-0/`, `eval-1/` etc.). Não crie tudo isso de antemão — crie os diretórios conforme avança.
### Passo 1: Dispare todas as execuções (com a skill E o baseline) no mesmo turno
Para cada caso de teste, dispare dois subagentes no mesmo turno — um com a
[…] Conteúdo completo no GitHub.Funciona com:Claude

