Claude Code Skills: Der vollständige Leitfaden für Einsteiger und Profis

no AI filler, active voice, specific and direct German prose.

Claude Code Skills sind Markdown-Dateien, die du einmalig anlegst und danach per Slash-Befehl oder Skill-Tool abrufst. Was simpel klingt, ist in der Praxis der entscheidende Hebel: Wer wiederkehrende Aufgaben als Skills definiert, reduziert Tippaufwand auf null und sorgt dafür, dass Claude jede Aufgabe exakt so angeht wie du es willst. Dieser Leitfaden zeigt dir, wie Skills aufgebaut sind, wie du sie konfigurierst und eigene entwickelst.

Was sind Claude Code Skills und warum sind sie wichtig?

Ein Skill ist im Kern ein Instruktionspaket. Du schreibst einmal auf, wie Claude eine bestimmte Aufgabe angehen soll, und rufst dieses Paket danach beliebig oft auf. Claude liest die Datei, verarbeitet den enthaltenen Kontext und führt die Schritte aus. Ohne Skills tippst du bei jeder Code-Review, jedem Deployment oder jedem Security-Audit dieselben Anweisungen neu.

Der Unterschied zu einer einfachen Notiz oder einem Prompt-Template liegt im System: Claude Code Skills integrieren sich direkt in die Tool-Architektur. Sie können Tools aufrufen, Dateien lesen, Argumente entgegennehmen und kontextbewusst reagieren. Ein gut geschriebener Skill weiß, wann er relevant ist, weil seine description präzise genug formuliert ist, dass Claude ihn automatisch triggert.

Für Teams bedeutet das: Alle Mitglieder führen dieselben Prozesse aus, ohne dass jemand Anweisungen abtippen oder Wikis nachschlagen muss. Der Skill ist die Dokumentation und die Automatisierung zugleich.

Einsatzgebiete im Entwickleralltag

• Code-Reviews: Prüfkriterien, Checklisten und Ausgabeformat einmalig definieren, danach per Slash-Befehl abrufen.
• Security-Audits: Bekannte Schwachstellenmuster als Skill kapseln und bei jedem Pull Request automatisch ausführen.
• Deployments: Umgebungserkennung, Preflight-Checks und Rollout-Schritte in einem Skill bündeln.
• Dokumentation: API-Docs, Changelogs oder Release Notes nach festem Schema generieren lassen.
• Refactoring: Analyse-Frameworks für Legacy-Code als wiederverwendbaren Workflow speichern.

Die Liste lässt sich beliebig erweitern. Jede Aufgabe, die du regelmäßig ausführst und die mehr als drei Sätze Beschreibung braucht, ist ein Kandidat für einen Skill.

Erste Schritte: Skills in Claude Code aktivieren und nutzen

Claude Code durchsucht beim Start mehrere Verzeichnisse nach Skill-Dateien. Das Verständnis dieser Hierarchie ist die Grundlage für alles Weitere. Es gibt drei Ebenen: globale Skills für alle Projekte, projektspezifische Skills und Plugin-Skills aus installierten Paketen.

~/.claude/
├── skills/
│   ├── security-review.md
│   ├── deployment.md
│   └── refactoring-guide.md
└── CLAUDE.md

.claude/                     # Projektspezifisch
├── skills/
│   ├── projekt-release.md
│   └── api-review.md
└── settings.json

Projektspezifische Skills überschreiben gleichnamige globale Skills. So kannst du einen globalen code-review-Skill für dein Unternehmen definieren und ihn in einem bestimmten Projekt mit einer angepassten Version überschreiben, ohne den globalen Skill zu verändern.

Einen Skill aufrufen

Der einfachste Aufruf ist der Slash-Befehl. Du tippst den Skill-Namen mit führendem Schrägstrich:

/security-review

Mit Argumenten sieht der Aufruf so aus:

/security-review --file src/auth.ts --depth thorough

Das Skill-Tool übernimmt die gesamte Orchestrierung: Es liest die Skill-Datei, ersetzt Platzhalter durch die übergebenen Argumente und gibt Claude die Instruktionen. Du siehst davon nichts direkt, außer dem Ergebnis.

Automatische Skill-Erkennung

Du musst einen Skill nicht immer explizit aufrufen. Claude liest beim Start alle verfügbaren Skill-Beschreibungen. Ist die description eines Skills präzise genug formuliert, erkennt Claude selbst, wann der Skill passt, und schlägt ihn vor oder ruft ihn direkt auf. Das macht gut dokumentierte Skills zu echten Automatisierungs-Bausteinen.

Ein Skill mit der Beschreibung “Verwende diesen Skill, wenn Code geprüft, bewertet oder auf Qualitätsprobleme analysiert werden soll” triggert zuverlässiger als einer mit “Für Code-Reviews”. Je konkreter die Beschreibung, desto präziser die automatische Erkennung.

Gebündelte Skills: Die wichtigsten vorinstallierten Skills im Überblick

Claude Code liefert eine Reihe von vorinstallierten Skills mit. Sie decken häufige Entwickleraufgaben ab und dienen gleichzeitig als Referenz für eigene Entwicklungen. Die Quelldateien dieser Skills zeigen Best Practices in der Praxis, bevor du dir eigene Konventionen überlegst.

Lies die Quelldateien dieser Skills bevor du eigene erstellst. Du siehst dort, wie erfahrene Entwickler description-Felder formulieren, wie Argumente strukturiert werden und wie Skill-Inhalte aufgebaut sind.

Skills konfigurieren: Name, Beschreibung und Argumente richtig setzen

Jede Skill-Datei beginnt mit einem YAML-Frontmatter zwischen zwei ----Trennern. Dieser Header ist das Fundament des Skills. Die drei Pflichtfelder sind name, description und optional arguments. Wie du sie ausfüllst, bestimmt direkt, wie zuverlässig und nützlich der Skill ist.

Das name-Feld

Der Wert im name-Feld wird zum Slash-Befehl. name: api-review erzeugt den Befehl /api-review. Verwende Bindestriche statt Leerzeichen, halte den Namen unter 25 Zeichen und wähle etwas, das du dir zwei Wochen später noch merken kannst.

---
name: api-review
description: Reviewt API-Endpunkte auf Konsistenz, Sicherheit und REST-Konventionen.
  Nutze diesen Skill, wenn neue Endpunkte gebaut oder bestehende überarbeitet werden.
arguments: Optional '--endpoint ' für einen einzelnen Endpunkt,
  '--focus security|style|performance' für den Prüfungsschwerpunkt.
---

Das description-Feld

Die description ist das wichtigste Feld für die automatische Erkennung. Claude liest alle verfügbaren Skill-Beschreibungen und entscheidet anhand dieser, welcher Skill zur aktuellen Aufgabe passt. Zwei Regeln gelten hier: Beschreibe den Anwendungsfall konkret, und nenne explizit, wann der Skill ausgeführt werden soll.

Schlechte Beschreibung: Für Code-Reviews.

Gute Beschreibung: Führt ein strukturiertes Code-Review durch. Verwende diesen Skill, wenn Code bewertet, geprüft oder auf Qualitätsprobleme analysiert werden soll — besonders vor dem Mergen von Feature-Branches.

Das arguments-Feld

Die arguments-Beschreibung richtet sich an Claude, nicht an einen Parser. Du beschreibst in natürlicher Sprache, welche Parameter der Skill akzeptiert. Claude liest diese Beschreibung und verarbeitet die übergebenen Werte entsprechend:

---
name: deploy
description: Führt ein Deployment in die angegebene Umgebung durch. Prüft
  vorher automatisch ob Tests grün sind und keine uncommittierten Änderungen
  vorliegen. Verwende diesen Skill für alle Deployments.
arguments: Zielumgebung 'staging' oder 'production'. Optional '--dry-run'
  für eine Simulation ohne tatsächliche Änderungen. Optional '--skip-tests'
  wenn Tests bereits extern geprüft wurden.
Deployment-Ziel: $ARGUMENTS

Führe folgende Schritte aus:
1. Git-Status prüfen — uncommittierte Änderungen stoppen den Prozess
2. Test-Suite ausführen (außer bei --skip-tests)
3. Deployment in die angegebene Umgebung durchführen
4. Health-Check nach dem Deployment ausführen

Im Skill-Inhalt greifst du mit $ARGUMENTS auf die übergebenen Werte zu. Claude setzt den Platzhalter durch die tatsächlich eingetippten Argumente.

Die Attribute span und size

Neben den Basis-Feldern unterstützt das Frontmatter zwei erweiterte Konfigurationsoptionen. Das Attribut span steuert, wie viel Kontext Claude beim Ausführen berücksichtigt. Mit size gibst du einen Hinweis zur Komplexität der Aufgabe:

---
name: full-project-audit
description: Vollständiges Audit eines Projekts — Dependencies, Security,
  Performance und Code-Qualität. Für große Projekte mehrere Minuten Laufzeit.
span: full
size: large
---

Für schnelle Einzeldatei-Checks setzt du den gegenteiligen Wert:

---
name: quick-lint
description: Schnelle Syntax-Prüfung einer einzelnen Datei.
span: minimal
size: small
---

Die Konfiguration über span und size hilft Claude, Ressourcen sinnvoll einzuteilen. Ein Skill mit size: large signalisiert, dass Claude tiefer analysieren soll. Ein Skill mit size: small zeigt an, dass eine schnelle, fokussierte Antwort erwartet wird.

Eigene Skills erstellen: Schritt-für-Schritt-Anleitung

Das Erstellen eines eigenen Skills dauert je nach Komplexität zwischen fünf und dreißig Minuten. Du brauchst einen Texteditor und ein klares Bild davon, was Claude tun soll. Die eigentliche Arbeit liegt in der Formulierung der Instruktionen — nicht im technischen Setup.

Schritt 1: Verzeichnis anlegen

# Globales Verzeichnis (verfügbar in allen Projekten)
mkdir -p ~/.claude/skills

# Projektspezifisches Verzeichnis
mkdir -p .claude/skills

Schritt 2: Skill-Datei erstellen

touch ~/.claude/skills/refactoring-guide.md

Schritt 3: Frontmatter schreiben

Fange mit dem YAML-Header an. Formuliere die description aus Sicht des Triggers: Wann soll dieser Skill verwendet werden? Konkrete Trigger-Sätze funktionieren besser als abstrakte Kategoriebezeichnungen:

---
name: refactoring-guide
description: Analysiert bestehenden Code und erstellt einen priorisierten
  Refactoring-Plan. Verwende diesen Skill, wenn Code verbessert, vereinfacht
  oder modernisiert werden soll — besonders bei Legacy-Code mit vielen
  Abhängigkeiten oder niedrigen Testwerten.
arguments: Optional '--target ' für einen spezifischen Bereich,
  '--strategy conservative|aggressive' für die Intensität des Refactorings.
---

Schritt 4: Skill-Inhalt strukturieren

Der Inhalt nach dem Frontmatter ist eine Markdown-Anleitung für Claude. Strukturiere ihn in nummerierte Schritte, damit die Ausführung reproduzierbar bleibt:

## Refactoring-Analyse für $ARGUMENTS

### 1. Ist-Zustand erfassen
- Lese alle relevanten Dateien im Zielbereich
- Identifiziere Code-Smells: Duplikate, God-Objects, lange Methoden
- Prüfe auf fehlende oder unzureichende Tests

### 2. Refactoring-Maßnahmen ableiten
- Priorisiere nach Aufwand/Nutzen-Verhältnis (niedrig/hoch zuerst)
- Schlage konkrete Verbesserungen mit Codebeispielen vor
- Schätze Implementierungsaufwand in Stunden

### 3. Bericht ausgeben
Struktur des Berichts:
- Zusammenfassung (max. 5 Sätze)
- Priorisierte Maßnahmenliste mit Aufwandsschätzung
- Risiken bei konservativem vs. aggressivem Vorgehen
- Empfohlene Reihenfolge der Umsetzung

Schritt 5: Testen und iterieren

Starte Claude Code neu, damit die neue Skill-Datei geladen wird. Rufe den Skill dann mit verschiedenen Eingaben auf:

/refactoring-guide --target src/legacy --strategy conservative

Passt das Ergebnis nicht, überarbeite zuerst den Skill-Inhalt — nicht die Argumente. Die meisten Qualitätsprobleme in Skill-Outputs lassen sich auf unklare Instruktionen zurückführen, nicht auf falsche Konfiguration.

Fortgeschrittene Muster: Skills mit Tools und Context kombinieren

Einfache Skills mit Frontmatter und Instruktionstext decken viele Anwendungsfälle ab. Für komplexe Workflows kombinierst du Skills mit expliziten Tool-Aufrufen, Datei-Kontext und bedingter Logik. Damit entstehen Automatisierungen, die auf den aktuellen Projektzustand reagieren statt starr abzuarbeiten.

Tools im Skill-Inhalt steuern

Du kannst Claude im Skill-Inhalt direkt anweisen, bestimmte tools zu verwenden. Das ist besonders nützlich, wenn ein Skill immer mit derselben Abfolge von Dateisuchen, Grep-Operationen oder Web-Anfragen beginnen soll:

---
name: dependency-audit
description: Prüft alle Projekt-Dependencies auf Sicherheitslücken und
  veraltete Versionen. Verwendet Dateisuche und Web-Recherche.
span: full
size: large
## Dependency-Audit

Führe diese Schritte in dieser Reihenfolge aus:

1. Lese package.json, requirements.txt, Gemfile oder Cargo.toml
   (je nachdem welche Dateien im Projekt existieren)
2. Durchsuche den Code nach direkten Import-Statements
3. Prüfe für jede Major-Dependency den aktuellen Versionsstand
4. Identifiziere bekannte CVEs für verwendete Versionen
5. Erstelle eine sortierte Liste: kritisch → hoch → mittel → niedrig

Context gezielt laden

Skills können Claude anweisen, bestimmte Dateien vor der eigentlichen Arbeit zu lesen. Das gibt jedem Skill-Aufruf denselben Wissensstand — ohne manuelle Kontextübergabe. Die CLAUDE.md-Datei ist dabei besonders wertvoll:

---
name: pr-description
description: Generiert eine Pull-Request-Beschreibung basierend auf den
  geänderten Dateien und den Projektkconventionen aus CLAUDE.md.
## PR-Beschreibung erstellen

Lies zunächst folgende Dateien für den nötigen context:
- `CLAUDE.md` — Projektkonventionen, Technologie-Stack, PR-Standards
- Alle geänderten Dateien im aktuellen Branch

Erstelle dann eine PR-Beschreibung, die:
- Den Conventional-Commits-Standard aus CLAUDE.md befolgt
- Den verwendeten Technologie-Stack aus CLAUDE.md berücksichtigt
- Das Ausgabeformat des Teams aus CLAUDE.md verwendet

Bedingte Logik einbauen

Skills können Entscheidungslogik enthalten. Claude liest den Zustand des Projekts und wählt den Pfad entsprechend:

---
name: smart-release
description: Erstellt ein Release mit automatischer Umgebungserkennung.
  Prüft Branch, Tests und Changelog bevor das Release eingeleitet wird.
arguments: Optional '--target staging|production' um die Erkennung zu überschreiben.
## Smart Release

Analysiere zunächst den aktuellen Zustand:

**Erkennung (wenn kein --target gesetzt):**
- Branch = main → Production-Release vorbereiten
- Branch = develop → Staging-Release vorbereiten
- Anderer Branch → Warnung ausgeben, Prozess stoppen

**Pflicht-Checks vor jedem Release:**
1. Uncommittierte Änderungen vorhanden? → Stoppen
2. Tests grün? → Bei Fehler stoppen
3. CHANGELOG.md aktuell? → Bei fehlendem Eintrag warnen

Dann: Release-Prozess für $ARGUMENTS oder erkannte Umgebung durchführen.

Skills im Team teilen und in Workflows integrieren

Wer Claude Code Skills im Team einsetzt, braucht einen strukturierten Weg zur Verteilung. Einzelne Markdown-Dateien per Slack oder E-Mail weiterzugeben skaliert nicht. Das Plugin-System löst dieses Problem: Skills werden als Paket gebündelt, versioniert und zentral installiert.

Für Teams, die systematisch auf Workflow-Automatisierung setzen, sind Plugin-Skills das Bindeglied zwischen Claude Code und den bestehenden Entwicklungsprozessen. Alle Mitglieder nutzen dieselben Skill-Versionen, Updates spielst du zentral ein.

Ein Skill-Plugin erstellen

Ein Plugin ist ein Node-Paket mit einer definierten Verzeichnisstruktur:

team-claude-skills/
├── package.json
├── skills/
│   ├── code-review.md
│   ├── security-audit.md
│   ├── deployment.md
│   └── release-notes.md
└── README.md

Die package.json des Plugins zeigt Claude, wo die Skills liegen:

{
  "name": "@deinteam/claude-skills",
  "version": "1.2.0",
  "description": "Team-Standards als Claude Code Skills",
  "claude": {
    "skills": "./skills"
  }
}

Nach der Installation über das Plugin-System stehen alle Skills des Pakets sofort als Slash-Befehle zur Verfügung. Wenn du eine neue Skill-Version veröffentlichst, holen sich alle Entwickler das Update über den normalen Package-Manager.

CLAUDE.md als zentrales Konfigurationsdokument

Die CLAUDE.md-Datei und Skills bilden zusammen das Rückgrat eines automatisierten Entwicklungs-Workflows. In CLAUDE.md definierst du projektweite Konfigurationen, die deine Skills dann als context einlesen. Das Ergebnis: hochgradig kontextbewusste Automatisierungen ohne manuelle Übergaben.

# CLAUDE.md — Beispielstruktur

## Technologie-Stack
- Backend: FastAPI (Python 3.11)
- Frontend: React 18 mit TypeScript
- Datenbank: PostgreSQL 15, Redis für Caching

## Code-Konventionen
- Alle Funktionen brauchen Typ-Annotationen
- Tests sind Pflicht für neue Features (Ziel: 80% Coverage)
- PR-Titel folgen Conventional Commits (feat:, fix:, chore:)

## Deployment-Konfiguration
- Staging: automatisch bei Push auf develop
- Production: manuelles Deployment nach zwei Approvals

Ein Skill, der diese CLAUDE.md einliest, kennt sofort den technischen Stack, die Konventionen und den Deployment-Prozess. Der Unterschied zu einem generischen Skill ohne diesen context ist erheblich — besonders bei Review- und Deployment-Aufgaben.

Integration in CI/CD-Pipelines

Claude Code läuft auch im Headless-Modus und lässt sich in automatisierte Pipelines einbetten. So führt ein GitHub Actions Workflow bei jedem Pull Request automatisch den Security-Review-Skill aus:

# .github/workflows/claude-review.yml
name: Claude Security Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Claude Code Security Review
        run: |
          claude --headless --skill security-review \
            --file "${{ github.event.pull_request.changed_files }}"
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Kein Entwickler muss den Review manuell anstoßen. Der Skill läuft bei jedem PR automatisch, gibt strukturiertes Feedback und blockiert bei kritischen Findings. Das ist der Punkt, an dem Claude Code Skills von einem nützlichen Werkzeug zu echter Prozess-Infrastruktur werden — vergleichbar mit dem, was eine spezialisierte KI-Unterstützung für Unternehmensprozesse leistet.

Fehlerbehebung: Häufige Probleme mit Claude Code Skills lösen

Die meisten Probleme mit Claude Code Skills lassen sich auf vier Ursachenkategorien zurückführen: falscher Speicherort, Frontmatter-Fehler, unklare Beschreibungen und Namenskonflikte. Ein systematischer Check dieser vier Bereiche löst neun von zehn Problemen.

Skill wird nicht erkannt

Wenn der Slash-Befehl nicht verfügbar ist oder Claude den Skill nicht findet, prüfe zuerst die Grundlagen:

• Falsches Verzeichnis: Die Datei muss in ~/.claude/skills/ oder .claude/skills/ liegen, nicht in Unterverzeichnissen.
• Fehlende Dateiendung: Skills müssen als .md-Dateien gespeichert sein.
• Frontmatter-Syntaxfehler: Der YAML-Block muss mit --- beginnen und enden. Tabs im YAML brechen den Parser.
• Claude Code nicht neu gestartet: Nach dem Anlegen neuer Skills startest du Claude Code neu.

# Skill-Verzeichnisse prüfen
ls ~/.claude/skills/
ls .claude/skills/

Skill liefert schlechte Ergebnisse

Der Skill wird erkannt, aber die Ausgabe passt nicht. Das liegt fast immer an der Qualität der Instruktionen:

• Zu vage description: Überarbeite das Feld mit konkreten Trigger-Szenarien.
• Fehlender Kontext im Inhalt: Weise Claude explizit an, bestimmte Dateien zu lesen.
• Unstrukturierter Skill-Inhalt: Ersetze Fließtext durch nummerierte Schritte.
• Fehlender $ARGUMENTS-Platzhalter: Ohne diesen Platzhalter ignoriert Claude die übergebenen Argumente.

Namenskonflikte erkennen

Projektskills überschreiben globale Skills mit demselben Namen. Wenn ein Skill unerwartet verhält, prüfe alle Ebenen auf Duplikate:

# Alle Skill-Ebenen auf denselben Namen prüfen
ls ~/.claude/skills/ | grep "code-review"
ls .claude/skills/ | grep "code-review"

Performance-Probleme bei komplexen Skills

Skills, die viele Dateien lesen oder lange Instruktionen enthalten, können langsam werden. Setze span: minimal und size: small für schnelle Checks. Teile große Skills in mehrere spezialisierte Skills auf, anstatt alles in eine Datei zu packen.

CLAUDE.md nicht gefunden

Verweist ein Skill auf CLAUDE.md und liefert unerwartete Ergebnisse, prüfe ob die Datei im Projektstammverzeichnis existiert. Der /init-Skill legt sie automatisch an:

/init

Die offizielle Claude Code Dokumentation von Anthropic enthält die vollständige Referenz für CLAUDE.md-Konventionen und Skill-Konfigurationsoptionen. Wer tiefer in die Open-Source-Architektur von Claude einsteigen möchte, findet im OpenClaude-Leitfaden weiterführende Einblicke.

Häufig gestellte Fragen zu Claude Code Skills

Was ist der Unterschied zwischen einem Skill und einem Slash-Befehl?

Der Slash-Befehl ist die Eingabe, der Skill ist die Datei dahinter. Wenn du /security-review tippst, ist das der Slash-Befehl. Die Datei security-review.md mit Frontmatter und Instruktionen ist der Skill. Das Skill-Tool liest die Datei und gibt Claude die Instruktionen.

Kann Claude einen Skill automatisch auswählen, ohne dass ich den Slash-Befehl tippe?

Ja, wenn die description präzise genug ist. Claude liest alle verfügbaren Skill-Beschreibungen und erkennt, welcher Skill zur aktuellen Aufgabe passt. Je konkreter die Beschreibung formuliert ist, desto zuverlässiger funktioniert die automatische Erkennung.

Wie viele Skills kann ich installieren?

Eine feste Obergrenze gibt es nicht. In der Praxis wirken sich zu viele inaktive Skills auf die automatische Erkennung aus, weil Claude mehr Beschreibungen auswerten muss. Installiere nur Skills, die du regelmäßig nutzt. Alles andere bündelst du in einem separaten Plugin, das du bei Bedarf aktivierst.

Kann ich einen Skill aus einem anderen Projekt übernehmen?

Kopiere die Markdown-Datei in dein globales Skills-Verzeichnis unter ~/.claude/skills/. Für die systematische Verteilung im Team nimmst du den Plugin-Weg: Skills als Paket bündeln, versionieren und über den Package-Manager installieren.

Sind Claude Code Skills mit allen Claude-Modellen kompatibel?

Skills funktionieren mit allen Modellen, die über Claude Code verfügbar sind. Das size-Attribut gibt Komplexitätshinweise, erzwingt aber keine bestimmte Modellversion. Die Modellauswahl konfigurierst du separat in der Claude Code-Konfiguration.

Darf ich API-Keys oder Passwörter in Skills speichern?

Nein. Skill-Dateien landen häufig in Versionskontrollsystemen. Speichere sensible Daten als Umgebungsvariablen und verweise im Skill-Inhalt auf diese. Claude liest Umgebungsvariablen aus der aktiven Shell-Session und stellt sie dem Skill zur Verfügung.

Wie unterscheidet sich ein globaler Skill von einem Plugin-Skill?

Globale Skills in ~/.claude/skills/ verwaltest du manuell. Plugin-Skills kommen aus installierten Paketen, werden versioniert und lassen sich zentral updaten. Für den Einzelentwickler reichen globale Skills. Für Teams mit mehreren Entwicklern und einheitlichen Standards ist das Plugin-System der richtige Weg.

Was passiert, wenn zwei Skills denselben Namen haben?

Projektspezifische Skills überschreiben globale Skills, globale Skills überschreiben Plugin-Skills. Die Hierarchie lautet: Projekt > Global > Plugin. Du kannst diese Hierarchie nutzen, um teamweite Standards projektspezifisch anzupassen, ohne die gemeinsamen Skills zu verändern.