Cómo Desarrollar Habilidades de Código con Claude Code Skills-Creator

Escribir manualmente archivos SKILL.md para cada herramienta personalizada de Claude Code se siente como escribir `package.json` a mano en 2023: tedioso, propenso a errores y completamente evitable. Skills-Creator automatiza este proceso transformando descripciones en lenguaje natural en definiciones de habilidades listas para producción, completas con la configuración del servidor MCP y la generación de manifiestos. Tú describes lo que quieres; él se encarga del código repetitivo.

¿Qué son las habilidades de Claude Code y por qué Skills-Creator lo cambia todo?

Las habilidades de Claude Code amplían las capacidades de tu asistente de IA más allá de la generación de código. Una habilidad empaqueta una herramienta, sus parámetros y la lógica de ejecución en un formato que Claude puede descubrir e invocar. El Protocolo de Contexto del Modelo (MCP) lo hace posible, pero escribir archivos SKILL.md requiere `frontmatter` YAML preciso, esquemas de parámetros y ejemplos de uso, repetidamente.

Skills-Creator elimina esa repetición. Es una meta-habilidad: una habilidad que construye habilidades. Proporcionas una descripción de alto nivel como "Crear una habilidad que consulte bases de datos PostgreSQL y devuelva resultados formateados," y genera:

Un SKILL.md completo con `frontmatter` adecuado
Esquemas de validación de parámetros
Ejemplos de uso y definiciones de tipos de retorno
`manifest.json` opcional para publicación

Para los equipos que construyen herramientas internas, esto significa que puedes lanzar diez habilidades personalizadas en el tiempo que solía tomar lanzar una sola. Para los desarrolladores individuales, significa no volver a olvidar un campo de parámetro requerido.

💡

¿Quieres una excelente herramienta de prueba de API que genere hermosa documentación de API?

¿Quieres una plataforma integrada y todo en uno para que tu equipo de desarrolladores trabaje junto con máxima productividad?

Apidog satisface todas tus demandas y reemplaza a Postman a un precio mucho más asequible!

botón

Prerrequisitos: Configuración de tu entorno de desarrollo

Antes de usar Skills-Creator, necesitas Claude Code con soporte MCP y una estructura de directorios para tus habilidades.

Instalar Claude Code

Si aún no lo has hecho, instala la CLI de Claude Code:

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

Verifica la instalación:

claude --version
# Debería mostrar algo como >= 2.0.70

Configurar MCP en Claude Code

Crea el directorio y archivo de configuración:

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

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

Agrega la configuración del servidor de Skills-Creator:

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

Clonar el repositorio de Skills-Creator

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

Esto compila la habilidad en /path/to/skills-creator/dist/index.js. Usa la ruta absoluta en tu config.json.

Configurar el directorio de salida de habilidades

mkdir -p ~/claude-skicks

La variable de entorno SKILLS_OUTPUT_DIR le indica a Skills-Creator dónde escribir las habilidades generadas.

Construyendo tu primera habilidad con Skills-Creator: Guía paso a paso

Construyamos una habilidad que genere especificaciones OpenAPI a partir de tipos de TypeScript, una necesidad común para los desarrolladores de backend.

Paso 1: Inicia Claude Code e invoca Skills-Creator

claude

Una vez que Claude carga, verifica que Skills-Creator esté disponible:

/list-tools

Deberías ver:

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

Paso 2: Describe tu habilidad

En el `prompt` de Claude, escribe:

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.

Skills-Creator analiza esta descripción y extrae:

Nombre de la habilidad: openapi-generator
Entrada: interfaces de TypeScript (archivos o código en bruto)
Salida: YAML de OpenAPI 3.0
Características: rutas, esquemas, ejemplos

Paso 3: Revisa el SKILL.md generado

Después de unos segundos, Skills-Creator escribe ~/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

Desde el código

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

Formato de retorno

La herramienta devuelve una cadena YAML que contiene:

openapi: "3.0.0"
info: Título, versión, descripción
paths: Rutas CRUD autogeneradas
components.schemas: Interfaces de TypeScript como esquemas


### Paso 4: Generar el Manifiesto (Opcional)

Si planeas publicar la habilidad en un marketplace, pídele a Skills-Creator que genere un manifiesto:

Create a manifest for the openapi-generator skill with license MIT, keywords openapi, typescript, backend, and repository URL https://github.com/your-org/openapi-generator-skill


Esto crea `~/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": [...]
  }
}

Comprendiendo los archivos generados: SKILL.md y Manifest

Skills-Creator no solo escribe YAML, sino que también impone las mejores prácticas. Analicemos la estructura del SKILL.md generado.

El bloque `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 clave:

name: Debe estar en `kebab-case`, único por servidor MCP
description: Usado por Claude para decidir cuándo invocar la habilidad
mcp.transport: stdio para servidores locales, http para remotos
tools: Cada herramienta se convierte en una función invocable

Esquema de parámetros:

type: string, number, boolean, array, object
required: Booleano
default: Valor predeterminado opcional
description: Crítico para la selección de parámetros de Claude

El cuerpo de Markdown

El cuerpo documenta los patrones de uso. Skills-Creator genera:

Encabezado: # Nombre de la Habilidad
Resumen: Qué hace la habilidad
Ejemplos de uso: Bloques de código que muestran `prompts` de Claude
Formato de retorno: Estructura de salida esperada

Esta documentación es utilizada por Claude Code cuando ejecutas /help openapi-generator.

El `Manifest.json`

El manifiesto agrega metadatos para compartir:

{
  "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 qué es importante: Cuando publicas en un marketplace como SkillsMP, el manifiesto habilita la búsqueda y el versionado.

Probando, iterando y desplegando tu habilidad personalizada

Paso 1: Implementar la lógica de la habilidad

Skills-Creator solo genera la definición. Debes escribir el manejador. Crea ~/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 });
  }
};

La función convertTypeScriptToOpenAPI es donde reside tu lógica de negocio. Usa librerías como ts-morph para analizar el AST de TypeScript.

Paso 2: Construye el servidor MCP

Crea ~/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');

Paso 3: Actualiza la configuración de Claude Code

Apuntar Claude Code al servidor de tu habilidad:

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

Paso 4: Prueba en Claude Code

claude

/list-tools

Deberías ver openapi-generator:generate-from-file y openapi-generator:generate-from-code.

Ejecuta una prueba:

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

Si funciona, verás la salida YAML. Si no, revisa los registros de MCP en el panel de salida de Claude Code.

Paso 5: Iterar con Skills-Creator

Si necesitas agregar una herramienta (ej. generate-from-database), no edites SKILL.md manualmente. Ejecuta:

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.

Skills-Creator hará lo siguiente:

Leer el SKILL.md existente
Agregar la nueva definición de herramienta
Actualizar la versión del manifiesto
Escribir una guía de migración en el cuerpo de markdown

Construyendo habilidades que construyen habilidades

Encadenamiento de meta-habilidades

Puedes construir una habilidad que use Skills-Creator internamente. Por ejemplo, un `skill-bootstrapper` que estructura nuevas habilidades basadas en plantillas.

// 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}` };
});

Gestión de versiones

Rastrea las versiones de las habilidades en Git:

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

Cuando Skills-Creator actualiza una habilidad, incrementa la versión en el manifiesto. Haz `commit` de cada versión para poder retroceder.

Probando habilidades programáticamente

// 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');
  });
});

Ejecuta pruebas antes de desplegar actualizaciones de habilidades.

Publicando tu habilidad

A un registro privado

Empaqueta tu habilidad como un paquete `npm`:

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

Tu equipo lo instala:

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

Actualiza la configuración de Claude Code:

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

Al marketplace SkillsMP

Crea una cuenta en skillsmp.com
Ejecuta skills-mp publish ~/claude-skills/openapi-generator
La CLI lee `manifest.json` y sube tu habilidad

Los usuarios pueden instalarlo a través de:

skills-mp install openapi-generator

Conclusión

Skills-Creator transforma el desarrollo de habilidades de una configuración manual a una generación automatizada. Tú describes la intención, él produce el código repetitivo. Tú te concentras en la lógica de negocio, él se encarga del cumplimiento del protocolo MCP. Para los equipos que construyen integraciones personalizadas de Claude Code, esto reduce el tiempo de desarrollo en un 80% y asegura la consistencia en las definiciones de habilidades. Comienza con una habilidad simple hoy, luego encadena Skills-Creator en tus tuberías de automatización para escalar las capacidades de los agentes en toda tu pila.

Cuando esas habilidades interactúen con tus APIs, valídalas con Apidog para garantizar contratos confiables entre agente y herramienta.

botón