Skill Creator: Erstelle effektive Claude-Skills

--- name: skill-creator description: Leitfaden zur Erstellung effektiver Skills. Dieser Skill sollte verwendet werden, wenn Benutzer einen neuen Skill erstellen (oder einen bestehenden Skill aktualisieren) möchten, der Claudes Fähigkeiten mit spezialisiertem Wissen, Workflows oder Tool-Integrationen erweitert. license: Vollständige Bedingungen in LICENSE.txt --- # Skill Creator Dieser Skill bietet Anleitungen zur Erstellung effektiver Skills. ## Über Skills Skills sind modulare, eigenständige Pakete, die Claudes Fähigkeiten erweitern, indem sie spezialisiertes Wissen, Workflows und Tools bereitstellen. Stellen Sie sie sich als "Onboarding-Leitfäden" für bestimmte Domänen oder Aufgaben vor - sie verwandeln Claude von einem Allzweck-Agenten in einen spezialisierten Agenten, der mit prozeduralem Wissen ausgestattet ist, das kein Modell vollständig besitzen kann. ### Was Skills bieten 1. Spezialisierte Workflows - Mehrstufige Verfahren für bestimmte Domänen 2. Tool-Integrationen - Anweisungen für die Arbeit mit bestimmten Dateiformaten oder APIs 3. Domänenexpertise - Unternehmensspezifisches Wissen, Schemata, Geschäftslogik 4. Gebündelte Ressourcen - Skripte, Referenzen und Assets für komplexe und wiederkehrende Aufgaben ## Kernprinzipien ### Prägnanz ist entscheidend Das Kontextfenster ist ein Gemeingut. Skills teilen sich das Kontextfenster mit allem anderen, was Claude benötigt: Systemprompt, Konversationsverlauf, Metadaten anderer Skills und die eigentliche Benutzeranfrage. **Standardannahme: Claude ist bereits sehr intelligent.** Fügen Sie nur Kontext hinzu, den Claude nicht bereits hat. Hinterfragen Sie jede Information: "Braucht Claude diese Erklärung wirklich?" und "Rechtfertigt dieser Absatz seine Token-Kosten?" Bevorzugen Sie prägnante Beispiele gegenüber ausführlichen Erklärungen. ### Angemessene Freiheitsgrade festlegen Passen Sie den Grad der Spezifität an die Fragilität und Variabilität der Aufgabe an: **Hohe Freiheit (textbasierte Anweisungen)**: Verwenden Sie dies, wenn mehrere Ansätze gültig sind, Entscheidungen vom Kontext abhängen oder Heuristiken den Ansatz leiten. **Mittlere Freiheit (Pseudocode oder Skripte mit Parametern)**: Verwenden Sie dies, wenn ein bevorzugtes Muster existiert, etwas Variation akzeptabel ist oder die Konfiguration das Verhalten beeinflusst. **Niedrige Freiheit (spezifische Skripte, wenige Parameter)**: Verwenden Sie dies, wenn Operationen fragil und fehleranfällig sind, Konsistenz entscheidend ist oder eine bestimmte Reihenfolge eingehalten werden muss. Stellen Sie sich Claude als Erkundung eines Pfades vor: Eine schmale Brücke mit Klippen benötigt spezifische Leitplanken (niedrige Freiheit), während ein offenes Feld viele Routen erlaubt (hohe Freiheit). ### Anatomie eines Skills Jeder Skill besteht aus einer erforderlichen SKILL.md-Datei und optionalen gebündelten Ressourcen: ``` skill-name/ ├── SKILL.md (erforderlich) │ ├── YAML-Frontmatter-Metadaten (erforderlich) │ │ ├── name: (erforderlich) │ │ └── description: (erforderlich) │ └── Markdown-Anweisungen (erforderlich) └── Gebündelte Ressourcen (optional) ├── scripts/ - Ausführbarer Code (Python/Bash/etc.) ├── references/ - Dokumentation, die bei Bedarf in den Kontext geladen werden soll └── assets/ - Dateien, die in der Ausgabe verwendet werden (Vorlagen, Symbole, Schriftarten, etc.) ``` #### SKILL.md (erforderlich) Jede SKILL.md besteht aus: - **Frontmatter** (YAML): Enthält die Felder `name` und `description`. Dies sind die einzigen Felder, die Claude liest, um zu bestimmen, wann der Skill verwendet wird. Daher ist es sehr wichtig, klar und umfassend zu beschreiben, was der Skill ist und wann er verwendet werden sollte. - **Hauptteil** (Markdown): Anweisungen und Leitfaden zur Verwendung des Skills. Wird erst NACH dem Auslösen des Skills geladen (falls überhaupt). #### Gebündelte Ressourcen (optional) ##### Skripte (`scripts/`) Ausführbarer Code (Python/Bash/etc.) für Aufgaben, die deterministische Zuverlässigkeit erfordern oder wiederholt neu geschrieben werden. - **Wann einbinden**: Wenn derselbe Code wiederholt neu geschrieben wird oder deterministische Zuverlässigkeit benötigt wird - **Beispiel**: `scripts/rotate_pdf.py` für PDF-Rotationsaufgaben - **Vorteile**: Token-effizient, deterministisch, kann ohne Laden in den Kontext ausgeführt werden - **Hinweis**: Skripte müssen möglicherweise dennoch von Claude gelesen werden, um Patches oder umgebungsspezifische Anpassungen vorzunehmen ##### Referenzen (`references/`) Dokumentation und Referenzmaterial, das bei Bedarf in den Kontext geladen werden soll, um Claudes Prozess und Denken zu informieren. - **Wann einbinden**: Für Dokumentation, auf die Claude während der Arbeit verweisen soll - **Beispiele**: `references/finance.md` für Finanzschemata, `references/mnda.md` für die unternehmenseigene NDA-Vorlage, `references/policies.md` für Unternehmensrichtlinien, `references/api_docs.md` für API-Spezifikationen - **Anwendungsfälle**: Datenbankschemata, API-Dokumentation, Domänenwissen, Unternehmensrichtlinien, detaillierte Workflow-Anleitungen - **Vorteile**: Hält SKILL.md schlank, wird nur geladen, wenn Claude feststellt, dass es benötigt wird - **Bewährte Praxis**: Wenn Dateien groß sind (>10.000 Wörter), grep-Suchmuster in SKILL.md aufnehmen - **Duplikation vermeiden**: Informationen sollten entweder in SKILL.md oder in Referenzdateien liegen, nicht in beiden. ##### Assets (`assets/`) Dateien, die nicht in den Kontext geladen werden sollen, sondern in der von Claude erzeugten Ausgabe verwendet werden. - **Wann einbinden**: Wenn der Skill Dateien benötigt, die in der endgültigen Ausgabe verwendet werden - **Beispiele**: `assets/logo.png` für Marken-Assets, `assets/slides.pptx` für PowerPoint-Vorlagen - **Anwendungsfälle**: Vorlagen, Bilder, Symbole, Boilerplate-Code, Schriftarten, Beispieldokumente ### Designprinzip der progressiven Offenlegung Skills verwenden ein dreistufiges Ladesystem, um den Kontext effizient zu verwalten: 1. **Metadaten (name + description)** - Immer im Kontext (~100 Wörter) 2. **SKILL.md-Hauptteil** - Wenn der Skill auslöst (<5.000 Wörter) 3. **Gebündelte Ressourcen** - Nach Bedarf von Claude Halten Sie den SKILL.md-Hauptteil auf das Wesentliche und unter 500 Zeilen, um eine Aufblähung des Kontexts zu minimieren. ## Skill-Erstellungsprozess Die Skill-Erstellung umfasst diese Schritte: 1. Den Skill mit konkreten Beispielen verstehen 2. Wiederverwendbare Skill-Inhalte planen (Skripte, Referenzen, Assets) 3. Den Skill initialisieren (init_skill.py ausführen) 4. Den Skill bearbeiten (Ressourcen implementieren und SKILL.md schreiben) 5. Den Skill paketieren (package_skill.py ausführen) 6. Basierend auf realer Nutzung iterieren ### Schritt 3: Initialisieren des Skills Wenn Sie einen neuen Skill von Grund auf erstellen, führen Sie immer das Skript `init_skill.py` aus: ```bash scripts/init_skill.py <skill-name> --path <output-directory> ``` ### Schritt 4: Den Skill bearbeiten Konsultieren Sie diese hilfreichen Leitfäden basierend auf den Anforderungen Ihres Skills: - **Mehrstufige Prozesse**: Siehe references/workflows.md für sequenzielle Workflows und bedingte Logik - **Spezifische Ausgabeformate oder Qualitätsstandards**: Siehe references/output-patterns.md für Vorlagen- und Beispielmuster ### Schritt 5: Paketieren eines Skills ```bash scripts/package_skill.py <path/to/skill-folder> ``` Das Paketierungsskript validiert und erstellt eine .skill-Datei für die Verteilung. DATEI:references/workflows.md # Workflow-Muster ## Sequenzielle Workflows Für komplexe Aufgaben zerlegen Sie Operationen in klare, sequenzielle Schritte. Es ist oft hilfreich, Claude zu Beginn der SKILL.md einen Überblick über den Prozess zu geben: ```markdown Das Ausfüllen eines PDF-Formulars umfasst diese Schritte: 1. Formular analysieren (analyze_form.py ausführen) 2. Feldzuordnung erstellen (fields.json bearbeiten) 3. Zuordnung validieren (validate_fields.py ausführen) 4. Formular ausfüllen (fill_form.py ausführen) 5. Ausgabe verifizieren (verify_output.py ausführen) ``` ## Bedingte Workflows Für Aufgaben mit Verzweigungslogik führen Sie Claude durch Entscheidungspunkte: ```markdown 1. Bestimmen Sie die Art der Änderung: **Neue Inhalte erstellen?** → Folgen Sie dem "Erstellungs-Workflow" unten **Bestehende Inhalte bearbeiten?** → Folgen Sie dem "Bearbeitungs-Workflow" unten 2. Erstellungs-Workflow: [Schritte] 3. Bearbeitungs-Workflow: [Schritte] ``` DATEI:references/output-patterns.md # Ausgabemuster Verwenden Sie diese Muster, wenn Skills konsistente, qualitativ hochwertige Ausgaben erzeugen müssen. ## Vorlagenmuster Stellen Sie Vorlagen für das Ausgabeformat bereit. Passen Sie den Grad der Strenge an Ihre Bedürfnisse an. **Für strenge Anforderungen (wie API-Antworten oder Datenformate):** ```markdown ## Berichtsstruktur Verwenden Sie IMMER diese exakte Vorlagenstruktur: # [Analysetitel] ## Zusammenfassung [Ein-Absatz-Überblick über die wichtigsten Erkenntnisse] ## Wichtigste Erkenntnisse - Erkenntnis 1 mit unterstützenden Daten - Erkenntnis 2 mit unterstützenden Daten - Erkenntnis 3 mit unterstützenden Daten ## Empfehlungen 1. Spezifische umsetzbare Empfehlung 2. Spezifische umsetzbare Empfehlung ``` **Für flexible Anleitung (wenn Anpassung nützlich ist):** ```markdown ## Berichtsstruktur Hier ist ein sinnvolles Standardformat, aber verwenden Sie Ihr bestes Urteilsvermögen: # [Analysetitel] ## Zusammenfassung [Überblick] ## Wichtigste Erkenntnisse [Abschnitte basierend auf dem anpassen, was Sie entdecken] ## Empfehlungen [Auf den spezifischen Kontext zuschneiden] Passen Sie Abschnitte nach Bedarf für den spezifischen Analysetyp an. ``` ## Beispiele-Muster Für Skills, bei denen die Ausgabequalität vom Sehen von Beispielen abhängt, stellen Sie Eingabe/Ausgabe-Paare bereit: ```markdown ## Commit-Nachrichtenformat Generieren Sie Commit-Nachrichten nach diesen Beispielen: **Beispiel 1:** Eingabe: Benutzerauthentifizierung mit JWT-Tokens hinzugefügt Ausgabe: ``` feat(auth): JWT-basierte Authentifizierung implementieren Login-Endpunkt und Token-Validierungs-Middleware hinzufügen ``` **Beispiel 2:** Eingabe: Fehler behoben, bei dem Daten in Berichten falsch angezeigt wurden Ausgabe: ``` fix(reports): Datumsformatierung bei Zeitzonenumrechnung korrigieren UTC-Zeitstempel konsistent über die Berichtserstellung hinweg verwenden ``` Folgen Sie diesem Stil: type(scope): kurze Beschreibung, dann detaillierte Erklärung. ``` Beispiele helfen Claude, den gewünschten Stil und das Detailniveau klarer zu verstehen als Beschreibungen allein. DATEI:scripts/quick_validate.py #!/usr/bin/env python3 """ Schnellvalidierungsskript für Skills - minimale Version """ import sys import os import re import yaml from pathlib import Path def validate_skill(skill_path): """Grundlegende Validierung eines Skills""" skill_path = Path(skill_path) # Prüfen, ob SKILL.md existiert skill_md = skill_path / 'SKILL.md' if not skill_md.exists(): return False, "SKILL.md nicht gefunden" # Frontmatter lesen und validieren content = skill_md.read_text() if not content.startswith('---'): return False, "Kein YAML-Frontmatter gefunden" # Frontmatter extrahieren match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL) if not match: return False, "Ungültiges Frontmatter-Format" frontmatter_text = match.group(1) # YAML-Frontmatter parsen try: frontmatter = yaml.safe_load(frontmatter_text) if not isinstance(frontmatter, dict): return False, "Frontmatter muss ein YAML-Wörterbuch sein" except yaml.YAMLError as e: return False, f"Ungültiges YAML im Frontmatter: {e}" # Zulässige Eigenschaften definieren ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata'} # Auf unerwartete Eigenschaften prüfen (außer verschachtelten Schlüsseln unter metadata) unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES if unexpected_keys: return False, ( f"Unerwartete Schlüssel im SKILL.md-Frontmatter: {', '.join(sorted(unexpected_keys))}. " f"Zulässige Eigenschaften sind: {', '.join(sorted(ALLOWED_PROPERTIES))}" ) # Pflichtfelder prüfen if 'name' not in frontmatter: return False, "'name' fehlt im Frontmatter" if 'description' not in frontmatter: return False, "'description' fehlt im Frontmatter" # Name für Validierung extrahieren name = frontmatter.get('name', '') if not isinstance(name, str): return False, f"Name muss eine Zeichenkette sein, erhalten: {type(name).__name__}" name = name.strip() if name: # Namenskonvention prüfen (hyphen-case: Kleinbuchstaben mit Bindestrichen) if not re.match(r'^[a-z0-9-]+$', name): return False, f"Name '{name}' sollte hyphen-case sein (nur Kleinbuchstaben, Ziffern und Bindestriche)" if name.startswith('-') or name.endswith('-') or '--' in name: return False, f"Name '{name}' darf nicht mit Bindestrich beginnen/enden oder aufeinanderfolgende Bindestriche enthalten" # Namenslänge prüfen (maximal 64 Zeichen laut Spezifikation) if len(name) > 64: return False, f"Name ist zu lang ({len(name)} Zeichen). Maximum ist 64 Zeichen." # Beschreibung extrahieren und validieren description = frontmatter.get('description', '') if not isinstance(description, str): return False, f"Beschreibung muss eine Zeichenkette sein, erhalten: {type(description).__name__}" description = description.strip() if description: # Auf spitze Klammern prüfen if '<' in description or '>' in description: return False, "Beschreibung darf keine spitzen Klammern (< oder >) enthalten" # Beschreibungslänge prüfen (maximal 1024 Zeichen laut Spezifikation) if len(description) > 1024: return False, f"Beschreibung ist zu lang ({len(description)} Zeichen). Maximum ist 1024 Zeichen." return True, "Skill ist gültig!" if __name__ == "__main__": if len(sys.argv) != 2: print("Verwendung: python quick_validate.py <skill-verzeichnis>") sys.exit(1) valid, message = validate_skill(sys.argv[1]) print(message) sys.exit(0 if valid else 1) DATEI:scripts/init_skill.py #!/usr/bin/env python3 """ Skill-Initialisierer - Erstellt einen neuen Skill aus einer Vorlage Verwendung: init_skill.py <skill-name> --path <pfad> Beispiele: init_skill.py my-new-skill --path skills/public init_skill.py my-api-helper --path skills/private init_skill.py custom-skill --path /custom/location """ import sys from pathlib import Path SKILL_TEMPLATE = """--- name: {skill_name} description: [TODO: Vollständige und informative Erklärung, was der Skill tut und wann er verwendet werden soll. Geben Sie an, WANN dieser Skill verwendet werden soll - spezifische Szenarien, Dateitypen oder Aufgaben, die ihn auslösen.] --- # {skill_title} ## Übersicht [TODO: 1-2 Sätze, die erklären, was dieser Skill ermöglicht] ## Ressourcen Dieser Skill enthält Beispiel-Ressourcenverzeichnisse, die demonstrieren, wie verschiedene Arten gebündelter Ressourcen organisiert werden: ### scripts/ Ausführbarer Code (Python/Bash/etc.), der direkt ausgeführt werden kann, um bestimmte Operationen durchzuführen. ### references/ Dokumentation und Referenzmaterial, das in den Kontext geladen werden soll, um Claudes Prozess und Denken zu informieren. ### assets/ Dateien, die nicht in den Kontext geladen werden sollen, sondern in der von Claude erzeugten Ausgabe verwendet werden. --- **Nicht benötigte Verzeichnisse können gelöscht werden.** Nicht jeder Skill erfordert alle drei Arten von Ressourcen. """ EXAMPLE_SCRIPT = '''#!/usr/bin/env python3 """ Beispiel-Hilfsskript für {skill_name} Dies ist ein Platzhalterskript, das direkt ausgeführt werden kann. Durch die tatsächliche Implementierung ersetzen oder löschen, falls nicht benötigt. """ def main(): print("Dies ist ein Beispielskript für {skill_name}") # TODO: Tatsächliche Skriptlogik hier hinzufügen if __name__ == "__main__": main() ''' EXAMPLE_REFERENCE = """# Referenzdokumentation für {skill_title} Dies ist ein Platzhalter für detaillierte Referenzdokumentation. Durch tatsächlichen Referenzinhalt ersetzen oder löschen, falls nicht benötigt. """ EXAMPLE_ASSET = """# Beispiel-Asset-Datei Dieser Platzhalter repräsentiert, wo Asset-Dateien gespeichert würden. Durch tatsächliche Asset-Dateien (Vorlagen, Bilder, Schriftarten, etc.) ersetzen oder löschen, falls nicht benötigt. """ def title_case_skill_name(skill_name): """Bindestrich-Skillnamen in Titelform für die Anzeige umwandeln.""" return ' '.join(word.capitalize() for word in skill_name.split('-')) def init_skill(skill_name, path): """Ein neues Skill-Verzeichnis mit Vorlagen-SKILL.md initialisieren.""" skill_dir = Path(path).resolve() / skill_name if skill_dir.exists(): print(f"❌ Fehler: Skill-Verzeichnis existiert bereits: {skill_dir}") return None try: skill_dir.mkdir(parents=True, exist_ok=False) print(f"✅ Skill-Verzeichnis erstellt: {skill_dir}") except Exception as e: print(f"❌ Fehler beim Erstellen des Verzeichnisses: {e}") return None skill_title = title_case_skill_name(skill_name) skill_content = SKILL_TEMPLATE.format(skill_name=skill_name, skill_title=skill_title) skill_md_path = skill_dir / 'SKILL.md' try: skill_md_path.write_text(skill_content) print("✅ SKILL.md erstellt") except Exception as e: print(f"❌ Fehler beim Erstellen von SKILL.md: {e}") return None try: scripts_dir = skill_dir / 'scripts' scripts_dir.mkdir(exist_ok=True) example_script = scripts_dir / 'example.py' example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name)) example_script.chmod(0o755) print("✅ scripts/example.py erstellt") references_dir = skill_dir / 'references' references_dir.mkdir(exist_ok=True) example_reference = references_dir / 'api_reference.md' example_reference.write_text(EXAMPLE_REFERENCE.format(skill_title=skill_title)) print("✅ references/api_reference.md erstellt") assets_dir = skill_dir / 'assets' assets_dir.mkdir(exist_ok=True) example_asset = assets_dir / 'example_asset.txt' example_asset.write_text(EXAMPLE_ASSET) print("✅ assets/example_asset.txt erstellt") except Exception as e: print(f"❌ Fehler beim Erstellen der Ressourcenverzeichnisse: {e}") return None print(f"\n✅ Skill '{skill_name}' erfolgreich initialisiert unter {skill_dir}") return skill_dir def main(): if len(sys.argv) < 4 or sys.argv[2] != '--path': print("Verwendung: init_skill.py <skill-name> --path <pfad>") sys.exit(1) skill_name = sys.argv[1] path = sys.argv[3] print(f"🚀 Initialisiere Skill: {skill_name}") print(f" Speicherort: {path}") print() result = init_skill(skill_name, path) sys.exit(0 if result else 1) if __name__ == "__main__": main() DATEI:scripts/package_skill.py #!/usr/bin/env python3 """ Skill-Paketierer - Erstellt eine verteilbare .skill-Datei aus einem Skill-Ordner Verwendung: python utils/package_skill.py <pfad/zum/skill-ordner> [ausgabeverzeichnis] Beispiel: python utils/package_skill.py skills/public/my-skill python utils/package_skill.py skills/public/my-skill ./dist """ import sys import zipfile from pathlib import Path from quick_validate import validate_skill def package_skill(skill_path, output_dir=None): """Einen Skill-Ordner in eine .skill-Datei paketieren.""" skill_path = Path(skill_path).resolve() if not skill_path.exists(): print(f"❌ Fehler: Skill-Ordner nicht gefunden: {skill_path}") return None if not skill_path.is_dir(): print(f"❌ Fehler: Pfad ist kein Verzeichnis: {skill_path}") return None skill_md = skill_path / "SKILL.md" if not skill_md.exists(): print(f"❌ Fehler: SKILL.md nicht gefunden in {skill_path}") return None print("🔍 Validiere Skill...") valid, message = validate_skill(skill_path) if not valid: print(f"❌ Validierung fehlgeschlagen: {message}") print(" Bitte beheben Sie die Validierungsfehler, bevor Sie paketieren.") return None print(f"✅ {message}\n") skill_name = skill_path.name if output_dir: output_path = Path(output_dir).resolve() output_path.mkdir(parents=True, exist_ok=True) else: output_path = Path.cwd() skill_filename = output_path / f"{skill_name}.skill" try: with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf: for file_path in skill_path.rglob('*'): if file_path.is_file(): arcname = file_path.relative_to(skill_path.parent) zipf.write(file_path, arcname) print(f" Hinzugefügt: {arcname}") print(f"\n✅ Skill erfolgreich paketiert nach: {skill_filename}") return skill_filename except Exception as e: print(f"❌ Fehler beim Erstellen der .skill-Datei: {e}") return None def main(): if len(sys.argv) < 2: print("Verwendung: python utils/package_skill.py <pfad/zum/skill-ordner> [ausgabeverzeichnis]") sys.exit(1) skill_path = sys.argv[1] output_dir = sys.argv[2] if len(sys.argv) > 2 else None print(f"📦 Paketiere Skill: {skill_path}") if output_dir: print(f" Ausgabeverzeichnis: {output_dir}") print() result = package_skill(skill_path, output_dir) sys.exit(0 if result else 1) if __name__ == "__main__": main()