Como Criar Habilidades de Código Claude com Claude Code Skills-Creator

Escrever manualmente arquivos SKILL.md para cada ferramenta customizada do Claude Code é como escrever package.json à mão em 2023 – tedioso, propenso a erros e completamente evitável. O Skills-Creator automatiza este processo, transformando descrições em linguagem natural em definições de skills prontas para produção, completas com configuração de servidor MCP e geração de manifesto. Você descreve o que deseja; ele cuida da parte burocrática.

O Que São Claude Code Skills e Por Que o Skills-Creator Muda Tudo?

Claude Code skills estendem as capacidades do seu assistente de IA além da geração de código. Uma skill empacota uma ferramenta, seus parâmetros e a lógica de execução em um formato que o Claude pode descobrir e invocar. O Model Context Protocol (MCP) torna isso possível, mas escrever arquivos SKILL.md exige frontmatter YAML preciso, esquemas de parâmetros e exemplos de uso – repetidamente.

O Skills-Creator elimina essa repetição. É uma meta-skill: uma skill que constrói skills. Você fornece uma descrição de alto nível como "Criar uma skill que consulta bancos de dados PostgreSQL e retorna resultados formatados," e ele gera:

Um SKILL.md completo com frontmatter adequado
Esquemas de validação de parâmetros
Exemplos de uso e definições de tipo de retorno
Manifesto.json opcional para publicação

Para equipes que desenvolvem ferramentas internas, isso significa que você pode enviar dez skills personalizadas no tempo que costumava levar para enviar uma. Para desenvolvedores solo, significa nunca mais esquecer um campo de parâmetro obrigatório.

💡

Quer uma ótima ferramenta de Teste de API que gera documentação de API bonita?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar em conjunto com máxima produtividade?

Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!

button

Pré-requisitos: Configurando Seu Ambiente de Desenvolvimento

Antes de usar o Skills-Creator, você precisa do Claude Code com suporte a MCP e uma estrutura de diretórios para suas skills.

Instalar o Claude Code

Se você ainda não o fez, instale a CLI do Claude Code:

npm install -g @anthropic-ai/claude-code

Verifique a instalação:

claude --version
# Deve mostrar algo como >= 2.0.70

Configurar o MCP no Claude Code

Crie o diretório de configuração e o arquivo:

# macOS/Linux
mkdir -p ~/.config/claude-code
touch ~/.config/claude-code/config.json

# Windows
mkdir %APPDATA%\claude-code
echo {} > %APPDATA%\claude-code\config.json

Adicione a configuração do servidor Skills-Creator:

{
  "mcpServers": {
    "skills-creator": {
      "command": "node",
      "args": ["/path/to/skills-creator/dist/index.js"],
      "env": {
        "SKILLS_OUTPUT_DIR": "~/claude-skills"
      }
    }
  }
}

Clonar o Repositório do Skills-Creator

git clone https://github.com/anthropics/skills.git
cd skills/skills/skill-creator
npm install
npm run build

Isso compila a skill para /path/to/skills-creator/dist/index.js. Use o caminho absoluto em seu config.json.

Configurar o Diretório de Saída das Skills

mkdir -p ~/claude-skicks

A variável de ambiente SKILLS_OUTPUT_DIR informa ao Skills-Creator onde gravar as skills geradas.

Construindo Sua Primeira Skill com o Skills-Creator: Guia Passo a Passo

Vamos construir uma skill que gera especificações OpenAPI a partir de tipos TypeScript – uma necessidade comum para desenvolvedores de backend.

Passo 1: Iniciar o Claude Code e Invocar o Skills-Creator

claude

Assim que o Claude carregar, verifique se o Skills-Creator está disponível:

/list-tools

Você deve ver:

Available tools:
- skills-creator:generate-skill (Generate a new skill from description)

Passo 2: Descreva Sua Skill

No prompt do Claude, digite:

Use the skills-creator tool to generate a skill called "openapi-generator" that takes TypeScript interface definitions and generates OpenAPI 3.0 YAML specs. The skill should accept file paths or raw TypeScript code as input and return a valid OpenAPI spec with paths, schemas, and example responses.

O Skills-Creator analisa esta descrição e extrai:

Nome da skill: openapi-generator
Entrada: interfaces TypeScript (arquivos ou código raw)
Saída: OpenAPI 3.0 YAML
Funcionalidades: paths, schemas, exemplos

Passo 3: Revise o SKILL.md Gerado

Após alguns segundos, o Skills-Creator escreve ~/claude-skills/openapi-generator/SKILL.md:

---
name: openapi-generator
description: Generates OpenAPI 3.0 specifications from TypeScript interfaces
version: 1.0.0
author: Claude Skills Creator
mcp:
  transport: stdio
tools:
  generate-from-file:
    description: Generate OpenAPI spec from TypeScript file
    parameters:
      filePath:
        type: string
        description: Path to TypeScript file containing interfaces
        required: true
      includeExamples:
        type: boolean
        description: Include example values in schema
        default: true
  generate-from-code:
    description: Generate OpenAPI spec from raw TypeScript code
    parameters:
      code:
        type: string
        description: TypeScript interface definitions as string
        required: true
      title:
        type: string
        description: API title for the OpenAPI spec
        default: "Generated API"
---

# OpenAPI Generator Skill

This skill transforms TypeScript interfaces into OpenAPI 3.0 specifications.

## Usage Examples

### From File
```typescript
// Input: ~/project/src/types.ts
export interface User {
  id: number;
  name: string;
  email: string;
}

// Claude: Use openapi-generator with filePath "~/project/src/types.ts"
// Output: OpenAPI spec with User schema

Do Código

// Claude: Use openapi-generator with code "export interface Product {...}" and title "Product API"

Formato de Retorno

A ferramenta retorna uma string YAML contendo:

openapi: "3.0.0"
info: Título, versão, descrição
paths: Caminhos CRUD gerados automaticamente
components.schemas: Interfaces TypeScript como esquemas


### Step 4: Generate the Manifest (Optional)

If you plan to publish the skill to a marketplace, ask Skills-Creator to generate a manifest:

Crie um manifesto para a skill openapi-generator com licença MIT, palavras-chave openapi, typescript, backend e URL do repositório https://github.com/your-org/openapi-generator-skill


Isso cria `~/claude-skills/openapi-generator/manifest.json`:

```json
{
  "name": "openapi-generator",
  "version": "1.0.0",
  "description": "Generates OpenAPI 3.0 specs from TypeScript",
  "license": "MIT",
  "keywords": ["openapi", "typescript", "backend"],
  "repository": {
    "type": "git",
    "url": "https://github.com/your-org/openapi-generator-skill"
  },
  "mcp": {
    "transport": "stdio",
    "tools": [...]
  }
}

Compreendendo os Arquivos Gerados: SKILL.md e Manifesto

O Skills-Creator não apenas escreve YAML – ele impõe as melhores práticas. Vamos dissecar a estrutura do SKILL.md gerado.

O Bloco Frontmatter

---
name: openapi-generator
description: Generates OpenAPI 3.0 specifications from TypeScript interfaces
version: 1.0.0
author: Claude Skills Creator
mcp:
  transport: stdio
tools:
  generate-from-file:
    description: Generate OpenAPI spec from TypeScript file
    parameters:
      filePath:
        type: string
        description: Path to TypeScript file containing interfaces
        required: true
---

Campos chave:

name: Deve ser em kebab-case, único por servidor MCP
description: Usado pelo Claude para decidir quando invocar a skill
mcp.transport: stdio para local, http para servidores remotos
tools: Cada ferramenta se torna uma função invocável

Esquema de parâmetros:

type: string, number, boolean, array, object
required: Booleano
default: Valor padrão opcional
description: Crítico para a seleção de parâmetros do Claude

O Corpo do Markdown

O corpo documenta os padrões de uso. O Skills-Creator gera:

Título: # Nome da Skill
Visão geral: O que a skill faz
Exemplos de uso: Blocos de código mostrando prompts do Claude
Formato de Retorno: Estrutura de saída esperada

Esta documentação é usada pelo Claude Code quando você executa /help openapi-generator.

O Manifest.json

O manifesto adiciona metadados para compartilhamento:

{
  "name": "openapi-generator",
  "version": "1.0.0",
  "description": "...",
  "license": "MIT",
  "keywords": ["openapi", "typescript", "backend"],
  "repository": {
    "type": "git",
    "url": "https://github.com/your-org/openapi-generator-skill"
  },
  "mcp": { ... }
}

Por que é importante: Quando você publica em um marketplace como o SkillsMP, o manifesto permite busca e versionamento.

Testando, Iterando e Implementando Sua Skill Personalizada

Passo 1: Implementar a Lógica da Skill

O Skills-Creator gera apenas a definição. Você deve escrever o handler. Crie ~/claude-skills/openapi-generator/index.ts:

import { z } from 'zod';
import { convertTypeScriptToOpenAPI } from './converter';

// Schema for tool parameters
const FileParams = z.object({
  filePath: z.string(),
  includeExamples: z.boolean().default(true)
});

const CodeParams = z.object({
  code: z.string(),
  title: z.string().default("Generated API")
});

// MCP Tool Handlers
export const tools = {
  'generate-from-file': async (params: unknown) => {
    const { filePath, includeExamples } = FileParams.parse(params);
    const fs = await import('fs');
    const code = fs.readFileSync(filePath, 'utf8');
    return convertTypeScriptToOpenAPI(code, { includeExamples });
  },
  
  'generate-from-code': async (params: unknown) => {
    const { code, title } = CodeParams.parse(params);
    return convertTypeScriptToOpenAPI(code, { title });
  }
};

A função convertTypeScriptToOpenAPI é onde sua lógica de negócios reside. Use bibliotecas como ts-morph para analisar a AST do TypeScript.

Passo 2: Construir o Servidor MCP

Crie ~/claude-skills/openapi-generator/server.ts:

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { tools } from './index';

const server = new Server({
  name: 'openapi-generator',
  version: '1.0.0'
}, {
  tools: Object.keys(tools).map(name => ({
    name,
    description: `Tool: ${name}`,
    inputSchema: {} // Will be overridden by SKILL.md
  }))
});

server.setRequestHandler('tools/call', async (request) => {
  const tool = tools[request.params.name];
  if (!tool) throw new Error(`Unknown tool: ${request.params.name}`);
  
  const result = await tool(request.params.arguments);
  return { content: [{ type: 'text', text: result }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);
console.error('OpenAPI Generator MCP server running');

Passo 3: Atualizar a Configuração do Claude Code

Aponte o Claude Code para o servidor da sua skill:

{
  "mcpServers": {
    "openapi-generator": {
      "command": "node",
      "args": ["~/claude-skills/openapi-generator/dist/server.js"]
    }
  }
}

Passo 4: Testar no Claude Code

claude

/list-tools

Você deve ver openapi-generator:generate-from-file e openapi-generator:generate-from-code.

Execute um teste:

Use openapi-generator to create an OpenAPI spec from the file ~/project/src/models/User.ts

Se funcionar, você verá a saída YAML. Se não, verifique os logs do MCP no painel de saída do Claude Code.

Passo 5: Iterar com o Skills-Creator

Se você precisar adicionar uma ferramenta (por exemplo, generate-from-database), não edite o SKILL.md manualmente. Execute:

Use skills-creator to add a new tool called generate-from-database to the openapi-generator skill. It should accept a database connection string and table name, then generate CRUD paths.

O Skills-Creator irá:

Ler o SKILL.md existente
Adicionar a nova definição de ferramenta
Atualizar a versão do manifesto
Escrever um guia de migração no corpo do markdown

Construindo Skills Que Constroem Skills

Encadeamento de Meta-Skills

Você pode construir uma skill que usa o Skills-Creator internamente. Por exemplo, um skill-bootstrapper que estrutura novas skills com base em templates.

// server/api/bootstrap-skill.post.ts
export default defineEventHandler(async (event) => {
  const { name, template } = await readBody(event);
  
  // Call Skills-Creator programmatically
  await $fetch('http://localhost:3001/generate-skill', {
    method: 'POST',
    body: {
      name,
      description: `Bootstrap ${template} skill`,
      template
    }
  });
  
  return { success: true, skillPath: `~/claude-skills/${name}` };
});

Gerenciamento de Versões

Rastreie as versões da skill no Git:

cd ~/claude-skills
git init
git add openapi-generator/
git commit -m "Initial openapi-generator skill"

Quando o Skills-Creator atualiza uma skill, ele incrementa a versão no manifesto. Faça commit de cada versão para possibilitar rollback.

Testando Skills Programaticamente

// test/skill.test.ts
import { describe, it, expect } from 'vitest';
import { tools } from '../openapi-generator/index';

describe('openapi-generator', () => {
  it('should generate spec from file', async () => {
    const result = await tools['generate-from-file']({
      filePath: './test/fixtures/User.ts',
      includeExamples: true
    });
    
    expect(result).toContain('openapi: 3.0.0');
    expect(result).toContain('User');
  });
});

Execute os testes antes de implementar as atualizações da skill.

Publicando Sua Skill

Para um Registro Privado

Empacote sua skill como um pacote npm:

// package.json
{
  "name": "@your-org/openapi-generator-skill",
  "version": "1.0.0",
  "main": "dist/server.js",
  "bin": { "openapi-generator-skill": "./bin/start.js" }
}

Sua equipe o instala:

npm install -g @your-org/openapi-generator-skill

Atualize a configuração do Claude Code:

{
  "mcpServers": {
    "openapi-generator": {
      "command": "openapi-generator-skill"
    }
  }
}

Para o Marketplace SkillsMP

Crie uma conta em skillsmp.com
Execute skills-mp publish ~/claude-skills/openapi-generator
A CLI lê manifest.json e faz o upload da sua skill

Os usuários podem então instalar via:

skills-mp install openapi-generator

Conclusão

O Skills-Creator transforma o desenvolvimento de skills de configuração manual para geração automatizada. Você descreve a intenção, ele produz o boilerplate. Você se concentra na lógica de negócios, ele lida com a conformidade do protocolo MCP. Para equipes que constroem integrações personalizadas com o Claude Code, isso reduz o tempo de desenvolvimento em 80% e garante consistência nas definições de skills. Comece com uma skill simples hoje e, em seguida, encadeie o Skills-Creator em seus pipelines de automação para escalar as capacidades do agente em toda a sua pilha.

Quando essas skills interagirem com suas APIs, valide-as com o Apidog para garantir contratos confiáveis entre agente e ferramenta.

button