Blog

Claude Code Skills erstellen mit Claude Code Skills-Creator

Ashley Goolam

Ashley Goolam

21 January 2026

Claude Code Skills erstellen mit Claude Code Skills-Creator

Das manuelle Schreiben von SKILL.md-Dateien für jedes benutzerdefinierte Claude Code-Tool fühlt sich an, als würde man 2023 package.json von Hand schreiben – mühsam, fehleranfällig und völlig vermeidbar. Skills-Creator automatisiert diesen Prozess, indem es Beschreibungen in natürlicher Sprache in produktionsreife Skill-Definitionen umwandelt, komplett mit MCP-Serverkonfiguration und Manifestgenerierung. Sie beschreiben, was Sie möchten; es kümmert sich um den Boilerplate-Code.

Was sind Claude Code Skills und warum verändert der Skills-Creator alles?

Claude Code Skills erweitern die Fähigkeiten Ihres KI-Assistenten über die Codegenerierung hinaus. Ein Skill verpackt ein Tool, seine Parameter und Ausführungslogik in einem Format, das Claude erkennen und aufrufen kann. Das Model Context Protocol (MCP) macht dies möglich, aber das Schreiben von SKILL.md-Dateien erfordert präzise YAML-Frontmatter, Parameterschemata und Anwendungsbeispiele – und das immer wieder.

Skills-Creator eliminiert diese Wiederholung. Es ist ein Meta-Skill: ein Skill, der Skills erstellt. Sie geben eine übergeordnete Beschreibung ein, wie „Erstelle einen Skill, der PostgreSQL-Datenbanken abfragt und formatierte Ergebnisse zurückgibt,“ und es generiert:

Für Teams, die interne Tools entwickeln, bedeutet dies, dass Sie zehn benutzerdefinierte Skills in der Zeit veröffentlichen können, die früher für einen einzigen Skill benötigt wurde. Für Solo-Entwickler bedeutet es, nie wieder ein erforderliches Parameterfeld zu vergessen.

💡
Möchten Sie ein großartiges API-Testtool, das schöne API-Dokumentation generiert?

Möchten Sie eine integrierte All-in-One-Plattform für Ihr Entwicklerteam, um mit maximaler Produktivität zusammenzuarbeiten?

Apidog erfüllt all Ihre Anforderungen und ersetzt Postman zu einem wesentlich günstigeren Preis!
Button

Voraussetzungen: Einrichtung Ihrer Entwicklungsumgebung

Bevor Sie Skills-Creator verwenden, benötigen Sie Claude Code mit MCP-Unterstützung und eine Verzeichnisstruktur für Ihre Skills.

Claude Code installieren

Falls noch nicht geschehen, installieren Sie die Claude Code CLI:

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

Installation überprüfen:

claude --version
# Should show something like >= 2.0.70

MCP in Claude Code konfigurieren

Erstellen Sie das Konfigurationsverzeichnis und die Datei:

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

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

Fügen Sie die Skills-Creator-Serverkonfiguration hinzu:

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

Skills-Creator Repository klonen

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

Dies erstellt den Skill unter /path/to/skills-creator/dist/index.js. Verwenden Sie den absoluten Pfad in Ihrer config.json.

Skills-Ausgabeverzeichnis einrichten

mkdir -p ~/claude-skicks

Die Umgebungsvariable SKILLS_OUTPUT_DIR weist Skills-Creator an, wo generierte Skills gespeichert werden sollen.

Ihren ersten Skill mit Skills-Creator erstellen: Schritt-für-Schritt-Anleitung

Lassen Sie uns einen Skill erstellen, der OpenAPI-Spezifikationen aus TypeScript-Typen generiert – ein häufiger Bedarf für Backend-Entwickler.

Schritt 1: Claude Code starten und Skills-Creator aufrufen

claude

Sobald Claude geladen ist, überprüfen Sie, ob Skills-Creator verfügbar ist:

/list-tools

Sie sollten sehen:

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

Schritt 2: Beschreiben Sie Ihren Skill

Geben Sie in der Claude-Eingabeaufforderung ein:

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 analysiert diese Beschreibung und extrahiert:

Schritt 3: Überprüfen Sie die generierte SKILL.md

Nach einigen Sekunden schreibt Skills-Creator ~/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

Aus Code

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

Rückgabeformat

Das Tool gibt einen YAML-String zurück, der Folgendes enthält:


### Schritt 4: Das Manifest generieren (optional)

Wenn Sie den Skill auf einem Marktplatz veröffentlichen möchten, bitten Sie Skills-Creator, ein Manifest zu generieren:

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


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

Die generierten Dateien verstehen: SKILL.md und Manifest

Skills-Creator schreibt nicht nur YAML – es setzt Best Practices durch. Lassen Sie uns die generierte SKILL.md-Struktur analysieren.

Der Frontmatter-Block

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

Schlüsselfelder:

Parameterschema:

Der Markdown-Text

Der Text dokumentiert Nutzungsmuster. Skills-Creator generiert:

  1. Header: # Skill Name
  2. Übersicht: Was der Skill tut
  3. Anwendungsbeispiele: Codeblöcke, die Claude-Eingabeaufforderungen zeigen
  4. Rückgabeformat: Erwartete Ausgabestruktur

Diese Dokumentation wird von Claude Code verwendet, wenn Sie /help openapi-generator ausführen.

Das Manifest.json

Das Manifest fügt Metadaten zum Teilen hinzu:

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

Warum es wichtig ist: Wenn Sie auf einem Marktplatz wie SkillsMP veröffentlichen, ermöglicht das Manifest die Suche und Versionskontrolle.

Testen, Iterieren und Bereitstellen Ihres benutzerdefinierten Skills

Schritt 1: Die Skill-Logik implementieren

Skills-Creator generiert nur die Definition. Sie müssen den Handler schreiben. Erstellen Sie ~/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 });
  }
};

Die Funktion convertTypeScriptToOpenAPI ist der Ort, an dem Ihre Geschäftslogik angesiedelt ist. Verwenden Sie Bibliotheken wie ts-morph, um TypeScript AST zu parsen.

Schritt 2: Den MCP-Server erstellen

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

Schritt 3: Claude Code-Konfiguration aktualisieren

Verweisen Sie Claude Code auf den Server Ihres Skills:

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

Schritt 4: In Claude Code testen

claude

/list-tools

Sie sollten openapi-generator:generate-from-file und openapi-generator:generate-from-code sehen.

Führen Sie einen Test aus:

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

Wenn es funktioniert, sehen Sie eine YAML-Ausgabe. Falls nicht, überprüfen Sie die MCP-Logs im Ausgabefenster von Claude Code.

Schritt 5: Mit Skills-Creator iterieren

Wenn Sie ein Tool hinzufügen müssen (z.B. generate-from-database), bearbeiten Sie SKILL.md nicht manuell. Führen Sie aus:

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 wird:

  1. Die bestehende SKILL.md lesen
  2. Die neue Tool-Definition hinzufügen
  3. Die Manifest-Version aktualisieren
  4. Eine Migrationsanleitung im Markdown-Text schreiben

Skills entwickeln, die Skills entwickeln

Meta-Skill-Verkettung

Sie können einen Skill erstellen, der Skills-Creator intern verwendet. Zum Beispiel einen skill-bootstrapper, der neue Skills basierend auf Vorlagen gerüstet.

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

Versionsverwaltung

Skill-Versionen in Git verfolgen:

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

Wenn Skills-Creator einen Skill aktualisiert, erhöht es die Version im Manifest. Committen Sie jede Version für ein Rollback.

Skills programmatisch testen

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

Führen Sie Tests aus, bevor Sie Skill-Updates bereitstellen.

Ihren Skill veröffentlichen

In einem privaten Register

Verpacken Sie Ihren Skill als npm-Paket:

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

Ihr Team installiert es:

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

Claude Code-Konfiguration aktualisieren:

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

Zum SkillsMP Marktplatz

  1. Erstellen Sie ein Konto unter skillsmp.com
  2. Führen Sie skills-mp publish ~/claude-skills/openapi-generator aus
  3. Die CLI liest manifest.json und lädt Ihren Skill hoch
SkillsMP Marktplatz

Benutzer können dann installieren über:

skills-mp install openapi-generator

Fazit

Skills-Creator verwandelt die Skill-Entwicklung von manueller Konfiguration in automatisierte Generierung. Sie beschreiben die Absicht, es produziert den Boilerplate-Code. Sie konzentrieren sich auf die Geschäftslogik, es kümmert sich um die MCP-Protokollkonformität. Für Teams, die benutzerdefinierte Claude Code-Integrationen entwickeln, reduziert dies die Entwicklungszeit um 80 % und gewährleistet Konsistenz über Skill-Definitionen hinweg. Beginnen Sie noch heute mit einem einfachen Skill und verketten Sie Skills-Creator dann in Ihre Automatisierungspipelines, um die Agentenfähigkeiten über Ihren gesamten Stack hinweg zu skalieren.

Wenn diese Skills mit Ihren APIs interagieren, validieren Sie sie mit Apidog, um zuverlässige Agent-Tool-Verträge zu gewährleisten.

Button

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload