Comment Développer les Compétences de Code de Claude avec Claude Code Skills-Creator

Écrire manuellement les fichiers SKILL.md pour chaque outil personnalisé de Claude Code donne l'impression d'écrire un package.json à la main en 2023 – c'est fastidieux, source d'erreurs et totalement évitable. Skills-Creator automatise ce processus en transformant des descriptions en langage naturel en définitions de compétences prêtes pour la production, complètes avec la configuration du serveur MCP et la génération de manifestes. Vous décrivez ce que vous voulez ; il gère le code passe-partout.

Que sont les compétences Claude Code et pourquoi le Skills-Creator change-t-il tout ?

Les compétences Claude Code étendent les capacités de votre assistant IA au-delà de la génération de code. Une compétence regroupe un outil, ses paramètres et sa logique d'exécution dans un format que Claude peut découvrir et invoquer. Le protocole de contexte de modèle (MCP) rend cela possible, mais l'écriture des fichiers SKILL.md nécessite un préambule YAML précis, des schémas de paramètres et des exemples d'utilisation – à plusieurs reprises.

Skills-Creator élimine cette répétition. C'est une méta-compétence : une compétence qui construit des compétences. Vous fournissez une description de haut niveau comme « Créer une compétence qui interroge des bases de données PostgreSQL et renvoie des résultats formatés », et il génère :

Un fichier SKILL.md complet avec un préambule approprié
Des schémas de validation des paramètres
Des exemples d'utilisation et des définitions de types de retour
Un fichier manifest.json optionnel pour la publication

Pour les équipes qui développent des outils internes, cela signifie que vous pouvez livrer dix compétences personnalisées dans le temps qu'il fallait auparavant pour en livrer une seule. Pour les développeurs indépendants, cela signifie ne plus jamais oublier un champ de paramètre obligatoire.

💡

Vous voulez un excellent outil de test d'API qui génère une belle documentation d'API ?

Vous voulez une plateforme intégrée et tout-en-un pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?

Apidog répond à toutes vos exigences et remplace Postman à un prix beaucoup plus abordable !

bouton

Prérequis : Configurer votre environnement de développement

Avant d'utiliser Skills-Creator, vous avez besoin de Claude Code avec support MCP et d'une structure de répertoires pour vos compétences.

Installer Claude Code

Si ce n'est pas déjà fait, installez l'interface de ligne de commande (CLI) de Claude Code :

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

Vérifiez l'installation :

claude --version
# Devrait afficher quelque chose comme >= 2.0.70

Configurer le MCP dans Claude Code

Créez le répertoire et le fichier de configuration :

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

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

Ajoutez la configuration du serveur Skills-Creator :

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

Cloner le dépôt Skills-Creator

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

Ceci construit la compétence vers /chemin/vers/skills-creator/dist/index.js. Utilisez le chemin absolu dans votre config.json.

Configurer le répertoire de sortie des compétences

mkdir -p ~/claude-skicks

La variable d'environnement SKILLS_OUTPUT_DIR indique à Skills-Creator où écrire les compétences générées.

Construire votre première compétence avec Skills-Creator : Guide pas à pas

Construisons une compétence qui génère des spécifications OpenAPI à partir de types TypeScript – un besoin courant pour les développeurs backend.

Étape 1 : Démarrer Claude Code et invoquer Skills-Creator

claude

Une fois Claude chargé, vérifiez que Skills-Creator est disponible :

/list-tools

Vous devriez voir :

Outils disponibles :
- skills-creator:generate-skill (Générer une nouvelle compétence à partir d'une description)

Étape 2 : Décrire votre compétence

Dans l'invite Claude, tapez :

Utilisez l'outil skills-creator pour générer une compétence appelée "openapi-generator" qui prend des définitions d'interface TypeScript et génère des spécifications OpenAPI 3.0 YAML. La compétence doit accepter des chemins de fichiers ou du code TypeScript brut en entrée et renvoyer une spécification OpenAPI valide avec des chemins, des schémas et des exemples de réponses.

Skills-Creator analyse cette description et en extrait :

Nom de la compétence : openapi-generator
Entrée : interfaces TypeScript (fichiers ou code brut)
Sortie : OpenAPI 3.0 YAML
Fonctionnalités : chemins, schémas, exemples

Étape 3 : Examiner le fichier SKILL.md généré

Après quelques secondes, Skills-Creator écrit ~/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

À partir du code

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

Format de retour

L'outil renvoie une chaîne YAML contenant :

openapi : "3.0.0"
info : Titre, version, description
paths : Chemins CRUD auto-générés
components.schemas : Interfaces TypeScript en tant que schémas


### Étape 4 : Générer le manifeste (facultatif)

Si vous prévoyez de publier la compétence sur une place de marché, demandez à Skills-Creator de générer un manifeste :

Créez un manifeste pour la compétence openapi-generator avec la licence MIT, les mots-clés openapi, typescript, backend, et l'URL du dépôt https://github.com/your-org/openapi-generator-skill


Ceci crée `~/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": [...]
  }
}

Comprendre les fichiers générés : SKILL.md et Manifeste

Skills-Creator ne se contente pas d'écrire du YAML, il applique les meilleures pratiques. Décortiquons la structure du fichier SKILL.md généré.

Le bloc 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
---

Champs clés :

name : Doit être en kebab-case, unique par serveur MCP
description : Utilisé par Claude pour décider quand invoquer la compétence
mcp.transport : stdio pour les serveurs locaux, http pour les serveurs distants
tools : Chaque outil devient une fonction appelable

Schéma des paramètres :

type : string, number, boolean, array, object
required : Booléen
default : Valeur par défaut optionnelle
description : Crucial pour la sélection des paramètres par Claude

Le corps Markdown

Le corps documente les modèles d'utilisation. Skills-Creator génère :

En-tête : # Nom de la compétence
Vue d'ensemble : Ce que fait la compétence
Exemples d'utilisation : Blocs de code montrant les invites Claude
Format de retour : Structure de sortie attendue

Cette documentation est utilisée par Claude Code lorsque vous exécutez /help openapi-generator.

Le fichier Manifest.json

Le manifeste ajoute des métadonnées pour le partage :

{
  "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": { ... }
}

Pourquoi c'est important : Lorsque vous publiez sur une place de marché comme SkillsMP, le manifeste permet la recherche et le versionnement.

Tester, itérer et déployer votre compétence personnalisée

Étape 1 : Implémenter la logique de la compétence

Skills-Creator ne génère que la définition. Vous devez écrire le gestionnaire. Créez ~/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 fonction convertTypeScriptToOpenAPI est l'endroit où réside votre logique métier. Utilisez des bibliothèques comme ts-morph pour analyser l'AST TypeScript.

Étape 2 : Construire le serveur MCP

Créez ~/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('Serveur MCP OpenAPI Generator en cours d\'exécution');

Étape 3 : Mettre à jour la configuration de Claude Code

Indiquez à Claude Code le serveur de votre compétence :

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

Étape 4 : Tester dans Claude Code

claude

/list-tools

Vous devriez voir openapi-generator:generate-from-file et openapi-generator:generate-from-code.

Exécutez un test :

Utilisez openapi-generator pour créer une spécification OpenAPI à partir du fichier ~/project/src/models/User.ts

Si cela fonctionne, vous verrez une sortie YAML. Sinon, vérifiez les journaux MCP dans le panneau de sortie de Claude Code.

Étape 5 : Itérer avec Skills-Creator

Si vous devez ajouter un outil (par exemple, generate-from-database), n'éditez pas SKILL.md manuellement. Exécutez :

Utilisez skills-creator pour ajouter un nouvel outil appelé generate-from-database à la compétence openapi-generator. Il doit accepter une chaîne de connexion à la base de données et un nom de table, puis générer des chemins CRUD.

Skills-Creator va :

Lire le fichier SKILL.md existant
Ajouter la nouvelle définition d'outil
Mettre à jour la version du manifeste
Écrire un guide de migration dans le corps markdown

Construire des compétences qui construisent des compétences

Enchaînement de méta-compétences

Vous pouvez créer une compétence qui utilise Skills-Creator en interne. Par exemple, un skill-bootstrapper qui génère de nouvelles compétences basées sur des modèles.

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

Gestion des versions

Suivez les versions des compétences dans Git :

cd ~/claude-skills
git init
git add openapi-generator/
git commit -m "Compétence openapi-generator initiale"

Lorsque Skills-Creator met à jour une compétence, il incrémente la version dans le manifeste. Commitez chaque version pour permettre un retour en arrière.

Tester les compétences par programme

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

Exécutez les tests avant de déployer les mises à jour des compétences.

Publier votre compétence

Vers un registre privé

Empaquetez votre compétence en tant que package npm :

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

Votre équipe l'installe :

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

Mettez à jour la configuration de Claude Code :

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

Vers la place de marché SkillsMP

Créez un compte sur skillsmp.com
Exécutez skills-mp publish ~/claude-skills/openapi-generator
La CLI lit manifest.json et télécharge votre compétence

Les utilisateurs peuvent ensuite installer via :

skills-mp install openapi-generator

Conclusion

Skills-Creator transforme le développement de compétences d'une configuration manuelle à une génération automatisée. Vous décrivez l'intention, il produit le code passe-partout. Vous vous concentrez sur la logique métier, il gère la conformité au protocole MCP. Pour les équipes qui développent des intégrations personnalisées de Claude Code, cela réduit le temps de développement de 80 % et assure la cohérence des définitions de compétences. Commencez dès aujourd'hui avec une compétence simple, puis intégrez Skills-Creator dans vos pipelines d'automatisation pour étendre les capacités des agents à l'ensemble de votre pile technologique.

Lorsque ces compétences interagissent avec vos API, validez-les avec Apidog pour garantir des contrats agent-outil fiables.

bouton