Como Criar Skills de Código Claude Automaticamente com Skill Creator

TL;DR

As Habilidades de Código do Claude são capacidades personalizadas que estendem a funcionalidade do Claude para fluxos de trabalho específicos. O sistema Criador de Habilidades automatiza a criação de habilidades por meio de um processo estruturado: defina o propósito da sua habilidade, rascunhe o arquivo SKILL.md, crie casos de teste, execute avaliações com benchmarks quantitativos e itere para melhorar com base no feedback.

Introdução

Você usa o Código Claude diariamente. Você se percebe repetindo as mesmas sequências: configurando estruturas de projeto, executando comandos de teste específicos, formatando saídas de uma determinada maneira. A cada vez, você explica o fluxo de trabalho do zero. E se Claude lembrasse? E se você pudesse capturar esse fluxo de trabalho uma vez e tê-lo disponível para sempre? É isso que as Habilidades de Código do Claude fazem. São capacidades personalizadas que você cria para estender a funcionalidade do Claude para seus fluxos de trabalho específicos. E com o Criador de Habilidades, o processo é automatizado e sistemático.

Este guia o conduzirá por todo o processo. Você aprenderá a anatomia da habilidade, o fluxo de trabalho de criação, o sistema de avaliação e como otimizar para um acionamento confiável. Você verá exemplos práticos do repositório oficial de habilidades da Anthropic.

💡

Se você está construindo habilidades relacionadas a APIs, o Apidog se integra naturalmente. Teste seus endpoints de API, valide respostas e gere documentação, tudo dentro de um único fluxo de trabalho de habilidade.

botão

O Que São Habilidades de Código do Claude?

Habilidades de Código do Claude são conjuntos de instruções especializadas que estendem as capacidades do Claude para domínios ou fluxos de trabalho específicos. Pense nelas como plugins personalizados que residem em arquivos markdown.

A Arquitetura do Sistema de Habilidades

As habilidades usam um sistema de carregamento de três níveis:

Metadados (~100 palavras) - Nome e descrição, sempre em contexto
Corpo do SKILL.md (<500 linhas) - Instruções centrais, carregadas quando a habilidade é acionada
Recursos empacotados (ilimitados) - Scripts, referências, ativos carregados sob demanda

skill-name/
├── SKILL.md (obrigatório)
│   ├── YAML frontmatter (nome, descrição)
│   └── Instruções Markdown
└── Recursos Empacotados (opcional)
    ├── scripts/    - Código executável para tarefas repetitivas
    ├── references/ - Documentação carregada conforme necessário
    └── assets/     - Modelos, ícones, fontes

Quando as Habilidades São Acionadas

As habilidades aparecem na lista available_skills do Claude com seu nome e descrição. Claude decide se deve consultar uma habilidade com base nessa descrição.

Importante: As habilidades só são acionadas para tarefas que Claude não consegue lidar diretamente. Consultas simples como “leia este arquivo” não acionarão uma habilidade, mesmo com uma descrição correspondente. Fluxos de trabalho complexos e de várias etapas são acionados de forma confiável quando a descrição corresponde.

Exemplos do Mundo Real do Repositório da Anthropic

Habilidade	Propósito	Principais Recursos
skill-creator	Cria novas habilidades	Geração de casos de teste, avaliação de benchmark, otimização de descrição
mcp-builder	Constrói servidores MCP	Modelos Python/Node, estrutura de avaliação, melhores práticas
docx	Gera documentos Word	Scripts python-docx, sistema de modelos, guia de estilo
pdf	Extrai e manipula PDFs	Manuseio de formulários, extração de texto, documentos de referência
frontend-design	Constrói interfaces web	Biblioteca de componentes, padrões Tailwind, verificações de acessibilidade

O Fluxo de Trabalho de Criação de Habilidades

O processo de criação de habilidades segue um ciclo sistemático:

Capturar intenção - O que a habilidade deve fazer?
Escrever um rascunho - Criar o arquivo SKILL.md
Criar casos de teste - Definir prompts realistas
Executar avaliações - Executar com e sem a habilidade
Revisar resultados - Feedback qualitativo + métricas quantitativas
Iterar - Melhorar com base nas descobertas
Otimizar descrição - Maximizar a precisão do acionamento
Empacotar - Distribuir como um arquivo .skill

Vamos percorrer cada etapa.

Etapa 1: Capturar Intenção

Comece entendendo o que você quer que a habilidade realize. Se você está capturando um fluxo de trabalho que já estava fazendo, extraia o padrão do seu histórico de conversas.

Faça estas quatro perguntas:

O que esta habilidade deve permitir que Claude faça? Seja específico sobre o resultado.
Quando esta habilidade deve ser acionada? Quais frases ou contextos do usuário?
Qual é o formato de saída esperado? Arquivos, código, relatórios?
Devemos configurar casos de teste? Habilidades com saídas verificáveis (geração de código, extração de dados, transformações de arquivo) se beneficiam de casos de teste. Habilidades com saídas subjetivas (estilo de escrita, design) geralmente não precisam deles.

Exemplo: Habilidade de Teste de API

Intenção: Ajudar desenvolvedores a testar APIs REST sistematicamente
Acionamento: Quando o usuário menciona teste de API, endpoints, REST, GraphQL, ou quer validar respostas
Saída: Relatórios de teste com status de aprovação/reprovação, comandos curl, comparações de resposta
Casos de teste: Sim - as saídas são objetivamente verificáveis

Etapa 2: Escrever o Arquivo SKILL.md

Toda habilidade começa com um arquivo SKILL.md contendo frontmatter YAML e instruções markdown.

Anatomia da Habilidade

---
name: api-tester
description: Como testar APIs REST sistematicamente. Use quando os usuários mencionarem teste de API, endpoints, REST, GraphQL, ou quiserem validar respostas de API. Certifique-se de sugerir esta habilidade sempre que o teste estiver envolvido.
compatibility: Requer curl ou ferramentas de cliente HTTP
---

# Habilidade Testador de API

## Fluxo de Trabalho Principal

Ao testar uma API, siga estas etapas:

1. **Entenda o endpoint** - Leia a especificação ou peça o esquema
2. **Projete casos de teste** - Caminho feliz, casos extremos, condições de erro
3. **Execute testes** - Use curl ou Apidog para requisições
4. **Valide respostas** - Verifique códigos de status, cabeçalhos, estrutura do corpo
5. **Relate resultados** - Resuma aprovação/reprovação com evidências

## Modelo de Caso de Teste

Para cada endpoint, teste:

- Autenticação válida com payload correto
- Autenticação válida com campos obrigatórios ausentes
- Autenticação inválida (esperado 401)
- Comportamento de limitação de taxa
- Tempo de resposta sob carga

## Formato de Saída

Sempre estruture relatórios assim:

# Relatório de Teste de API

## Resumo
- Testes executados: X
- Aprovados: Y
- Reprovados: Z

## Testes Reprovados

### Nome do Teste
**Esperado:** 200 OK
**Atual:** 400 Bad Request
**Resposta:** {...}

## Recomendações
...

Melhores Práticas de Escrita

Use divulgação progressiva: Mantenha o SKILL.md com menos de 500 linhas. Mova referências detalhadas para arquivos separados.

api-tester/
├── SKILL.md (visão geral do fluxo de trabalho)
└── references/
    ├── authentication.md
    ├── rate-limiting.md
    └── response-codes.md

Explique o porquê: Não apenas liste regras. Explique por que elas são importantes.

## Por que testamos casos de erro primeiro

Testar condições de erro antes dos caminhos felizes captura 80% dos problemas mais rapidamente.
Quando a autenticação falha silenciosamente, os testes de caminho feliz se tornam sem sentido.
Comece com a verificação 401.

Use a forma imperativa: “Sempre valide o código de status primeiro” e não “Você deveria validar…”

Inclua exemplos: Mostre a entrada e a saída esperada.

## Formato da mensagem de commit

**Exemplo:**
Entrada: Autenticação de usuário adicionada com tokens JWT
Saída: feat(auth): implementar autenticação baseada em JWT

Etapa 3: Criar Casos de Teste

Depois de rascunhar a habilidade, crie 2-3 prompts de teste realistas. São os tipos de requisições que um usuário real faria.

Formato do Caso de Teste

Salve os casos de teste em evals/evals.json:

{
  "skill_name": "api-tester",
  "evals": [
    {
      "id": 1,
      "prompt": "Testar o endpoint /users em api.example.com - ele precisa de um token Bearer e retorna uma lista de usuários com campos id, name, email",
      "expected_output": "Relatório de teste com pelo menos 5 casos de teste, incluindo falha de autenticação, sucesso e testes de paginação",
      "files": []
    },
    {
      "id": 2,
      "prompt": "Preciso verificar se nosso novo endpoint POST /orders lida corretamente com quantidades inválidas",
      "expected_output": "Casos de teste que enviam quantidades negativas, zero e não numéricas com respostas de erro apropriadas",
      "files": ["openapi.yaml"]
    }
  ]
}

O Que Torna um Bom Prompt de Teste

Ruim: “Testar esta API”

Bom: “ok, minha equipe acabou de implantar este novo endpoint de pagamentos em https://api.stripe.com/v1/charges e preciso verificar se ele lida com casos extremos – especificamente o que acontece quando você envia um valor negativo ou um código de moeda que não existe. A documentação diz que deve retornar 400, mas quero ver as mensagens de erro reais”

O bom prompt de teste inclui:

URL específico
Cenário concreto
Comportamento esperado
Contexto do mundo real

Compartilhe seus casos de teste com o usuário antes de executá-los: “Aqui estão alguns cenários de teste que gostaria de experimentar. Estão corretos, ou você gostaria de adicionar mais?”

Etapa 4: Executar Avaliações

É aqui que o Criador de Habilidades brilha. Você executará cada caso de teste duas vezes: uma com a habilidade, outra sem (ou com a versão antiga, se estiver melhorando uma habilidade existente).

Estrutura do Workspace

Os resultados vão para <skill-name>-workspace/ como um irmão do diretório da habilidade:

api-tester-workspace/
├── iteration-1/
│   ├── eval-0-auth-failure/
│   │   ├── with_skill/
│   │   │   ├── outputs/
│   │   │   └── timing.json
│   │   ├── without_skill/
│   │   │   ├── outputs/
│   │   │   └── timing.json
│   │   └── eval_metadata.json
│   ├── eval-1-pagination/
│   │   └── ...
│   ├── benchmark.json
│   └── benchmark.md
├── iteration-2/
└── feedback.json

Iniciar Execuções Paralelas

Para cada caso de teste, crie dois subagentes no mesmo turno:

Execução com a habilidade:

Execute esta tarefa:
- Caminho da habilidade: /path/to/api-tester
- Tarefa: Testar o endpoint /users em api.example.com
- Arquivos de entrada: nenhum
- Salvar saídas em: api-tester-workspace/iteration-1/eval-0/with_skill/outputs/

Execução de linha de base:

Execute esta tarefa:
- Caminho da habilidade: (nenhum)
- Tarefa: Testar o endpoint /users em api.example.com
- Arquivos de entrada: nenhum
- Salvar saídas em: api-tester-workspace/iteration-1/eval-0/without_skill/outputs/

Capturar Dados de Tempo

Quando cada subagente é concluído, você recebe total_tokens e duration_ms. Salve imediatamente em timing.json:

{
  "total_tokens": 84852,
  "duration_ms": 23332,
  "total_duration_seconds": 23.3
}

Esses dados só são enviados pela notificação de tarefa. Processe cada um assim que chegar.

Etapa 5: Rascunhar Asserções Enquanto as Execuções São Concluídas

Não espere apenas as execuções terminarem. Use esse tempo de forma produtiva rascunhando asserções quantitativas.

O Que Torna uma Boa Asserção

Boas asserções são:

Objetivamente verificáveis - A aprovação/reprovação é inequívoca
Com nomes descritivos - Claro o que está sendo verificado
Reutilizáveis - Funciona em todas as iterações

Exemplo de asserções para habilidade de teste de API:

{
  "assertions": [
    {
      "name": "includes_auth_failure_test",
      "description": "O relatório de teste inclui pelo menos um caso de teste de falha de autenticação",
      "type": "contains",
      "value": "401"
    },
    {
      "name": "includes_success_test",
      "description": "O relatório de teste inclui pelo menos um teste de requisição bem-sucedida",
      "type": "contains",
      "value": "200"
    },
    {
      "name": "includes_curl_commands",
      "description": "Cada caso de teste inclui comandos curl executáveis",
      "type": "regex",
      "value": "curl -"
    },
    {
      "name": "includes_response_validation",
      "description": "O relatório valida a estrutura da resposta em relação ao esquema",
      "type": "contains",
      "value": "schema"
    }
  ]
}

Atualize eval_metadata.json e evals/evals.json com asserções assim que forem rascunhadas.

Etapa 6: Avaliar e Agregar

Uma vez que todas as execuções são concluídas:

Avaliar Cada Execução

Crie um subagente avaliador que lê agents/grader.md e avalia cada asserção em relação às saídas. Salve os resultados em grading.json em cada diretório de execução:

{
  "eval_id": 0,
  "grading": [
    {
      "text": "includes_auth_failure_test",
      "passed": true,
      "evidence": "Encontrado código de status 401 no caso de teste 3"
    },
    {
      "text": "includes_curl_commands",
      "passed": true,
      "evidence": "Encontrado 'curl -X POST' no caso de teste 1"
    }
  ]
}

Importante: O array de expectativas de grading.json deve usar os nomes de campo text, passed e evidence. O visualizador depende desses nomes exatos.

Agregar em Benchmark

Execute o script de agregação do diretório skill-creator:

python -m scripts.aggregate_benchmark api-tester-workspace/iteration-1 --skill-name api-tester

Isso produz benchmark.json e benchmark.md com taxa de aprovação, tempo e tokens para cada configuração, incluindo média ± desvio padrão e delta.

Fazer uma Análise de Analista

Leia os dados do benchmark e identifique padrões:

Asserções não discriminatórias - Sempre aprovam, independentemente da habilidade (não são úteis)
Avaliações de alta variância - Possivelmente instáveis, precisam de investigação
Compromissos tempo/token - A habilidade melhora a qualidade a um custo razoável?

Veja agents/analyzer.md para orientação detalhada.

Etapa 7: Iniciar o Visualizador de Avaliações

O visualizador de avaliações mostra tanto as saídas qualitativas quanto as métricas quantitativas em uma interface de navegador.

Gerar o Visualizador

nohup python /path/to/skill-creator/eval-viewer/generate_review.py \
  api-tester-workspace/iteration-1 \
  --skill-name "api-tester" \
  --benchmark api-tester-workspace/iteration-1/benchmark.json \
  > /dev/null 2>&1 &
VIEWER_PID=$!

Para a iteração 2+, também passe --previous-workspace:

--previous-workspace api-tester-workspace/iteration-1

O Que o Usuário Vê

A aba Saídas mostra um caso de teste por vez:

Prompt - A tarefa dada
Saída - Arquivos produzidos, renderizados em linha
Saída Anterior (iteração 2+) - Seção recolhida com a saída da última iteração
Notas Formais - Aprovação/reprovação de asserção recolhida
Feedback - Caixa de texto que salva automaticamente conforme digitado
Feedback Anterior (iteração 2+) - Comentários da última iteração

A aba Benchmark mostra:

Taxas de aprovação para cada configuração
Comparações de tempo
Uso de tokens
Análises por avaliação
Observações do analista

Diga ao usuário: “Abri os resultados no seu navegador. Há duas abas – ‘Saídas’ permite que você clique em cada caso de teste e deixe feedback, ‘Benchmark’ mostra a comparação quantitativa. Quando terminar, volte aqui e me avise.”

Ambientes Cowork / Headless

Se webbrowser.open() não estiver disponível, use --static para escrever um arquivo HTML autônomo:

--static /path/to/output/review.html

O feedback é baixado como feedback.json quando o usuário clica em “Enviar Todas as Avaliações”.

Etapa 8: Ler o Feedback e Iterar

Quando o usuário terminar, leia feedback.json:

{
  "reviews": [
    {
      "run_id": "eval-0-with_skill",
      "feedback": "o gráfico está sem rótulos de eixo",
      "timestamp": "2026-03-23T10:30:00Z"
    },
    {
      "run_id": "eval-1-with_skill",
      "feedback": "",
      "timestamp": "2026-03-23T10:31:00Z"
    },
    {
      "run_id": "eval-2-with_skill",
      "feedback": "perfeito, adorei",
      "timestamp": "2026-03-23T10:32:00Z"
    }
  ],
  "status": "complete"
}

Feedback vazio significa que o usuário achou que estava bom. Concentre as melhorias nos casos de teste com reclamações específicas.

Como Pensar em Melhorias

Generalize a partir do feedback: Você está criando habilidades usadas milhares de vezes em muitos prompts. Não ajuste demais a casos de teste específicos. Se houver um problema persistente, tente metáforas ou padrões diferentes em vez de declarações restritivas do tipo DEVE.

Mantenha o prompt enxuto: Remova o que não está funcionando. Leia as transcrições, não apenas as saídas finais. Se a habilidade faz com que o modelo perca tempo em etapas improdutivas, remova essas partes.

Explique o porquê: LLMs têm boa teoria da mente. Quando recebem uma boa estrutura, elas vão além das instruções básicas. Explique por que cada requisito é importante. Se você se encontrar escrevendo SEMPRE ou NUNCA em letras maiúsculas, reformule e explique o raciocínio em vez disso.

Procure por trabalho repetido: Todos os casos de teste escreveram scripts auxiliares semelhantes de forma independente? Isso é um sinal de que a habilidade deve empacotar esse script. Escreva-o uma vez, coloque-o em scripts/ e diga à habilidade para usá-lo.

O Loop de Iteração

Aplique melhorias à habilidade
Execute novamente todos os casos de teste em iteration-<N+1>/ com execuções de linha de base
Inicie o visualizador com --previous-workspace apontando para a iteração anterior
Aguarde a revisão do usuário
Leia o novo feedback, melhore novamente, repita

Continue até:

O usuário dizer que está satisfeito
O feedback estiver todo vazio (tudo parece bom)
Você não estiver fazendo progresso significativo

Encerre o visualizador quando terminar:

kill $VIEWER_PID 2>/dev/null

Etapa 9: Otimizar a Descrição da Habilidade

O campo de descrição no frontmatter de SKILL.md é o principal mecanismo de acionamento. Após criar ou melhorar uma habilidade, otimize-a para uma melhor precisão de acionamento.

Gerar Consultas de Avaliação de Acionamento

Crie 20 consultas de avaliação - uma mistura de deve-acionar e não-deve-acionar:

[
  {
    "query": "ok então minha chefe acabou de me enviar este arquivo xlsx (está nos meus downloads, chamado algo como 'Q4 vendas final FINAL v2.xlsx') e ela quer que eu adicione uma coluna que mostre a margem de lucro como porcentagem. A receita está na coluna C e os custos na coluna D eu acho",
    "should_trigger": true
  },
  {
    "query": "Preciso criar uma tabela dinâmica a partir deste CSV e enviá-la por e-mail para a equipe",
    "should_trigger": false
  }
]

Para consultas que devem acionar (8-10):

Diferentes formas de expressar a mesma intenção
Linguagem formal e casual
Casos em que os usuários não nomeiam explicitamente a habilidade, mas claramente precisam dela
Casos extremos e usos incomuns

Para consultas que não devem acionar (8-10):

Quase acertos que compartilham palavras-chave, mas precisam de algo diferente
Domínios adjacentes onde outra ferramenta é mais apropriada
Fraseado ambíguo onde uma correspondência ingênua de palavras-chave acionaria incorretamente

Testes negativos ruins: “Escrever uma função fibonacci” como um teste negativo para uma habilidade de PDF é muito fácil. Os casos negativos devem ser genuinamente difíceis.

Revisar Com o Usuário

Apresente o conjunto de avaliação usando o modelo HTML:

Leia assets/eval_review.html
Substitua os marcadores de posição pelos dados de avaliação, nome da habilidade e descrição
Escreva para um arquivo temporário e abra: open /tmp/eval_review_api-tester.html
O usuário pode editar consultas, alternar deve-acionar, adicionar/remover entradas
O usuário clica em “Exportar Conjunto de Avaliação”
O arquivo é baixado para ~/Downloads/eval_set.json

Esta etapa é importante. Consultas de avaliação ruins levam a descrições ruins.

Executar o Loop de Otimização

python -m scripts.run_loop \
  --eval-set /path/to/trigger-eval.json \
  --skill-path /path/to/api-tester \
  --model claude-sonnet-4-6 \
  --max-iterations 5 \
  --verbose

Use o ID do modelo que está alimentando sua sessão atual para que os testes de acionamento correspondam ao que os usuários experimentam.

O script:

Divide o conjunto de avaliação em 60% treino, 40% teste retido
Avalia a descrição atual (3 execuções cada para confiabilidade)
Chama Claude para propor melhorias com base nas falhas
Reavalia no treino e no teste
Itera até 5 vezes
Retorna a best_description selecionada pela pontuação do teste (não pela pontuação do treino para evitar overfitting)

Aplicar o Resultado

Pegue a best_description da saída JSON e atualize o frontmatter SKILL.md da habilidade. Mostre ao usuário o antes/depois com as pontuações.

Antes:

description: Como testar APIs REST sistematicamente

Depois:

description: Como testar APIs REST sistematicamente. Use quando os usuários mencionam teste de API, endpoints, REST, GraphQL, ou querem validar respostas de API. Certifique-se de sugerir esta habilidade sempre que o teste estiver envolvido, mesmo que não mencionem explicitamente 'teste'.

Etapa 10: Empacotar e Distribuir

Uma vez que a habilidade esteja completa, empacote-a para distribuição:

python -m scripts.package_skill /path/to/api-tester

Isso cria um arquivo .skill que os usuários podem instalar. Direcione os usuários para o caminho do arquivo resultante.

Instalação

Os usuários instalam habilidades colocando o arquivo .skill em seu diretório de habilidades ou usando o comando de instalação de habilidades do Claude Code.

Erros Comuns na Criação de Habilidades

Erro 1: Descrição Vaga

Ruim:

description: Uma habilidade para trabalhar com APIs

Bom:

description: Como testar APIs REST sistematicamente. Use quando os usuários mencionam teste de API, endpoints, REST, GraphQL, ou querem validar respostas de API. Certifique-se de sugerir esta habilidade sempre que o teste estiver envolvido, mesmo que não mencionem explicitamente 'teste'.

Erro 2: Instruções Excessivamente Restritivas

Ruim:

SEMPRE use este formato exato. NUNCA se desvie. DEVE incluir estas seções.

Bom:

Use este formato porque ele garante que as partes interessadas possam encontrar rapidamente as informações de que precisam. Se o seu público tiver necessidades diferentes, adapte a estrutura de acordo.

Erro 3: Ignorar Casos de Teste

Os casos de teste identificam problemas antes que os usuários os encontrem. Mesmo para habilidades subjetivas, execute 2-3 exemplos para verificar a qualidade da saída.

Erro 4: Ignorar Dados de Tempo

Habilidades que levam 10 vezes mais tempo não são sustentáveis. Capture dados de tempo e otimize para eficiência junto com a qualidade.

Erro 5: Não Agrupar Scripts Repetidos

Se cada execução de teste escrever um generate_report.py de forma independente, agrupe-o na habilidade. Economiza tempo e garante consistência.

Exemplos de Habilidades do Mundo Real

Habilidade MCP Builder

Criado pela Anthropic para construir servidores MCP (Model Context Protocol).

Principais recursos:

Modelos Python e Node.js
Estrutura de avaliação para servidores MCP
Documentos de referência de melhores práticas

Estrutura:

mcp-builder/
├── SKILL.md
├── reference/
│   ├── mcp_best_practices.md
│   ├── python_mcp_server.md
│   └── node_mcp_server.md
└── evaluation/
    └── evaluation.md

Habilidade Docx

Gera documentos Word programaticamente.

Principais recursos:

Scripts python-docx agrupados
Sistema de modelos para documentos comuns
Guia de estilo para formatação consistente

Fluxo de trabalho:

Entender os requisitos do documento
Selecionar ou criar modelo
Gerar via script python-docx
Validar estrutura de saída

Habilidade de Design Frontend

Cria interfaces web com padrões modernos.

Principais recursos:

Biblioteca de componentes
Padrões Tailwind CSS
Verificações de acessibilidade

Divulgação progressiva: Fluxo de trabalho principal em SKILL.md, docs de componentes em references/.

Testando Sua Habilidade com Apidog

Se você está construindo habilidades relacionadas a APIs, o Apidog se integra naturalmente ao fluxo de trabalho.

A screenshot of the Apidog interface showing API testing features.

Exemplo: Integração da Habilidade de Teste de API

## Executando Testes de API

Use Apidog para testes sistemáticos:

1. Importe a especificação OpenAPI para o Apidog
2. Gere casos de teste a partir da especificação
3. Execute testes e exporte resultados como JSON
4. Valide respostas em relação aos esquemas esperados

Para asserções personalizadas, use o recurso de script do Apidog.

Agrupar Scripts Apidog

api-tester/
├── SKILL.md
└── scripts/
    ├── run-apidog-tests.py
    └── generate-report.py

Isso evita que cada invocação futura reinvente a roda.

Conclusão

As Habilidades de Código do Claude estendem as capacidades do Claude para seus fluxos de trabalho específicos. O sistema Criador de Habilidades fornece um processo sistemático:

Capturar intenção - Definir o que a habilidade deve fazer
Rascunhar SKILL.md - Escrever instruções claras com exemplos
Criar casos de teste - Prompts realistas que os usuários realmente fariam
Executar avaliações - Execução paralela com e sem a habilidade
Revisar resultados - Feedback qualitativo + benchmarks quantitativos
Iterar - Melhorar com base nas descobertas
Otimizar descrição - Maximizar a precisão do acionamento
Empacotar - Distribuir como arquivo .skill

botão

FAQ

Quanto tempo leva para criar uma habilidade?

Habilidades simples levam de 15 a 30 minutos. Habilidades complexas com vários arquivos de referência e scripts agrupados podem levar de 2 a 3 horas, incluindo iterações de avaliação.

Preciso escrever casos de teste para todas as habilidades?

Não. Habilidades com saídas objetivamente verificáveis (geração de código, transformações de arquivo, extração de dados) se beneficiam de casos de teste. Habilidades com saídas subjetivas (estilo de escrita, qualidade de design) são melhor avaliadas qualitativamente.

E se minha habilidade não for acionada de forma confiável?

Otimize o campo de descrição. Inclua frases e contextos de acionamento específicos. Torne-o um pouco "insistente" - declare explicitamente quando usar a habilidade. Execute o loop de otimização de descrição com 20 consultas de avaliação.

Como compartilho habilidades com minha equipe?

Empacote a habilidade com python -m scripts.package_skill <caminho> e, em seguida, distribua o arquivo .skill. Os membros da equipe o colocam em seu diretório de habilidades.

As habilidades podem chamar APIs externas?

Sim. Agrupe scripts que fazem chamadas de API. As instruções da habilidade dizem a Claude quando e como usá-los. Armazene as chaves de API em variáveis de ambiente, não na própria habilidade.

Qual é o limite de tamanho de arquivo para habilidades?

Não há limite rígido, mas mantenha o SKILL.md com menos de 500 linhas. Mova referências detalhadas para arquivos separados. Scripts e ativos não contam para o limite de linhas, pois são carregados sob demanda.

Como atualizo uma habilidade existente?

Copie a habilidade instalada para um local gravável, edite lá e empacote novamente. Preserve o nome original - não adicione sufixos de versão, a menos que esteja criando uma variante distinta.