> ## Documentation Index
> Fetch the complete documentation index at: https://docs.windsurf.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Skills

> Skills helfen Cascade, komplexe, mehrschrittige Aufgaben zu bewältigen.

Die schwierigsten Engineeringaufgaben erfordern oft mehr als nur gute Prompts. Sie können Referenzskripte, Vorlagen, Checklisten und andere unterstützende Dateien erfordern. Mit Skills können Sie all dies in Ordnern bündeln, die Cascade aufrufen (lesen und verwenden) kann.

Skills sind eine hervorragende Möglichkeit, Cascade beizubringen, mehrstufige Workflows konsistent auszuführen.

Cascade verwendet [**schrittweise Offenlegung**](https://agentskills.io/what-are-skills#how-skills-work): Standardmäßig werden dem Modell nur der `name` und die `description` des Skills angezeigt. Der vollständige Inhalt von `SKILL.md` und die zugehörigen Dateien werden **nur geladen, wenn Cascade entscheidet, den Skill aufzurufen** (oder wenn Sie ihn per `@mention` erwähnen). Dadurch bleibt Ihr Kontextfenster auch bei vielen definierten Skills schlank.

Weitere Details zur Skills-Spezifikation finden Sie auf [agentskills.io](https://agentskills.io/home).

<div id="how-to-create-a-skill">
  ## So erstellen Sie einen Skill
</div>

<div id="using-the-ui-easiest">
  ### Über die Benutzeroberfläche (am einfachsten)
</div>

1. Öffne das Cascade-Panel
2. Klicke auf die drei Punkte oben rechts im Panel, um das Customizations-Menü zu öffnen
3. Klicke auf den Bereich `Skills`
4. Klicke auf `+ Workspace`, um einen Workspace-spezifischen Skill zu erstellen, oder auf `+ Global`, um einen globalen Skill zu erstellen
5. Gib dem Skill einen Namen (nur Kleinbuchstaben, Ziffern und Bindestriche)

<div id="manual-creation">
  ### Manuelle Erstellung
</div>

**Workspace-Skill (projektspezifisch):**

1. Erstellen Sie ein Verzeichnis: `.windsurf/skills/<skill-name>/`
2. Legen Sie eine `SKILL.md`-Datei mit YAML-Frontmatter an

**Globaler Skill (in allen Workspaces verfügbar):**

1. Erstellen Sie ein Verzeichnis: `~/.codeium/windsurf/skills/<skill-name>/`
2. Legen Sie eine `SKILL.md`-Datei mit YAML-Frontmatter an

<div id="skillmd-file-format">
  ## SKILL.md-Dateiformat
</div>

Jeder Skill benötigt eine `SKILL.md`-Datei mit YAML-Frontmatter, die die Metadaten des Skills enthält:

<div id="example-skill">
  ### Beispiel-Skill
</div>

```markdown theme={null}
---
name: deploy-to-production
description: Guides the deployment process to production with safety checks
---

## Pre-deployment Checklist
1. Run all tests
2. Check for uncommitted changes
3. Verify environment variables

## Deployment Steps
Follow these steps to deploy safely...

[Reference supporting files in this directory as needed]
```

<div id="required-frontmatter-fields">
  ### Erforderliche Frontmatter-Felder
</div>

* **name**: Eindeutiger Bezeichner für den Skill (wird in der UI angezeigt und für @-Erwähnungen verwendet)
* **description**: Kurze Erklärung, die dem AI-Modell angezeigt wird, um ihm zu helfen zu entscheiden, wann der Skill aufgerufen werden soll

Beispiele für gültige Namen: `deploy-to-staging`, `code-review`, `setup-dev-environment`

<div id="adding-supporting-resources">
  ## Hinzufügen unterstützender Ressourcen
</div>

Platziere alle unterstützenden Dateien im Skill-Ordner neben `SKILL.md`. Diese Dateien werden für Cascade verfügbar, wenn der Skill aufgerufen wird:

```
.windsurf/skills/deploy-to-production/
├── SKILL.md
├── deployment-checklist.md
├── rollback-procedure.md
└── config-template.yaml
```

<div id="invoking-skills">
  ## Skills aufrufen
</div>

<div id="automatic-invocation">
  ### Automatisches Aufrufen
</div>

Wenn deine Anfrage mit der Beschreibung eines Skills übereinstimmt, ruft Cascade den Skill automatisch auf und verwendet dessen Anweisungen und Ressourcen, um die Aufgabe zu erledigen. Dies ist die am häufigsten genutzte Art, Skills zu verwenden – du beschreibst einfach, was du tun möchtest, und Cascade bestimmt, welche Skills relevant sind.

Das Feld `description` im Frontmatter deines Skills ist entscheidend: Es hilft Cascade zu verstehen, wann der Skill aufgerufen werden soll. Schreibe Beschreibungen, die klar erklären, was der Skill macht und wann er verwendet werden sollte.

<div id="manual-invocation">
  ### Manuelles Auslösen
</div>

Sie können einen Skill jederzeit explizit auslösen, indem Sie `@skill-name` in das Cascade-Eingabefeld eingeben. Dies ist nützlich, wenn Sie sicherstellen möchten, dass ein bestimmter Skill verwendet wird, oder wenn Sie einen Skill ausführen möchten, der durch Ihre Anfrage möglicherweise nicht automatisch ausgelöst wird.

<div id="skill-scopes">
  ## Skill-Geltungsbereiche
</div>

| Geltungsbereich     | Speicherort                            | Verfügbarkeit                                                 |
| ------------------- | -------------------------------------- | ------------------------------------------------------------- |
| Workspace           | `.windsurf/skills/`                    | Nur aktueller Workspace. Mit Ihrem Repo versioniert.          |
| Global              | `~/.codeium/windsurf/skills/`          | Alle Workspaces auf Ihrem Rechner. Nicht versioniert.         |
| System (Enterprise) | Betriebssystemspezifisch (siehe unten) | Alle Workspaces, von der IT bereitgestellt. Schreibgeschützt. |

<Note>
  Für agentenübergreifende Kompatibilität erkennt Windsurf auch Skills in `.agents/skills/` und `~/.agents/skills/`. Wenn Sie das Lesen der Claude Code-Konfiguration aktiviert haben, werden außerdem `.claude/skills/` und `~/.claude/skills/` durchsucht.
</Note>

<div id="system-level-skills-enterprise">
  ### Skills auf Systemebene (Enterprise)
</div>

Enterprise-Organisationen können Skills bereitstellen, die in allen Workspaces verfügbar sind und nicht von Endnutzern geändert werden können:

| OS        | Pfad                                            |
| --------- | ----------------------------------------------- |
| macOS     | `/Library/Application Support/Windsurf/skills/` |
| Linux/WSL | `/etc/windsurf/skills/`                         |
| Windows   | `C:\ProgramData\Windsurf\skills\`               |

Jeder Skill ist ein Unterverzeichnis mit einer Datei namens `SKILL.md`, genau wie bei Workspace-Skills.

<div id="example-use-cases">
  ## Anwendungsbeispiele
</div>

<div id="deployment-workflow">
  ### Bereitstellungs-Workflow
</div>

Erstelle einen Skill mit Bereitstellungsskripten, Umgebungskonfigurationen und Rollback-Verfahren:

```
.windsurf/skills/deploy-staging/
├── SKILL.md
├── pre-deploy-checks.sh
├── environment-template.env
└── rollback-steps.md
```

<div id="code-review-guidelines">
  ### Richtlinien für Code-Reviews
</div>

Fügen Sie Styleguides, Sicherheitschecklisten und Review-Vorlagen hinzu:

```
.windsurf/skills/code-review/
├── SKILL.md
├── style-guide.md
├── security-checklist.md
└── review-template.md
```

<div id="testing-procedures">
  ### Testverfahren
</div>

Bündeln Sie Testvorlagen, Anforderungen an die Testabdeckung und CI/CD-Konfigurationen:

```
.windsurf/skills/run-tests/
├── SKILL.md
├── test-template.py
├── coverage-config.json
└── ci-workflow.yaml
```

<div id="best-practices">
  ## Best Practices
</div>

1. **Schreibe klare Beschreibungen**: Die Beschreibung hilft Cascade dabei zu entscheiden, wann der Skill aufgerufen werden soll. Sei präzise darin, was der Skill macht und wann er verwendet werden sollte.

2. **Relevante Ressourcen einbeziehen**: Vorlagen, Checklisten und Beispiele machen Skills nützlicher. Überlege, welche Dateien jemandem helfen würden, die Aufgabe zu erledigen.

3. **Aussagekräftige Namen verwenden**: `deploy-to-staging` ist besser als `deploy1`. Namen sollten klar erkennen lassen, was der Skill macht.

<div id="skills-vs-rules-vs-workflows">
  ## Skills vs Rules vs Workflows
</div>

Alle drei passen Cascade an, unterscheiden sich aber in **Struktur**, **Aufruf** und **Kontextkosten**:

|                            | Skills                                                                      | Rules                                                | Workflows                                   |
| -------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------- | ------------------------------------------- |
| **Zweck**                  | Mehrstufige Abläufe mit unterstützenden Dateien                             | Verhaltensregeln („wie sich Cascade verhalten soll“) | Prompt-Vorlagen für wiederholbare Aufgaben  |
| **Struktur**               | Ordner mit `SKILL.md` + beliebigen Ressourcendateien                        | Einzelne `.md`-Datei mit Frontmatter                 | Einzelne `.md`-Datei                        |
| **Aufruf**                 | AI-Modell entscheidet (schrittweise Offenlegung) oder `@mention`            | `always_on` / `glob` / `model_decision` / `manual`   | **Nur manuell** über `/slash-command`       |
| **Im System-Prompt?**      | Nein — nur Name + Beschreibung bis zum Aufruf                               | Hängt vom Aktivierungsmodus ab                       | Nein — als verfügbare Befehle aufgeführt    |
| **Am besten geeignet für** | Deployments, Code-Reviews und Testverfahren, die Skripte/Vorlagen benötigen | Code-Stil, Projektkonventionen, Vorgaben             | Einmalige Runbooks, die du explizit auslöst |

**Faustregel:** Wenn Cascade es automatisch aufgreifen soll *und* unterstützende Dateien benötigt, verwende einen Skill. Wenn es eine kurze Verhaltensvorgabe ist, verwende eine Rule. Wenn du es immer selbst auslösen möchtest, verwende einen Workflow.

<div id="related-documentation">
  ## Verwandte Dokumentation
</div>

Wenn Skills nicht das sind, was Sie suchen, sehen Sie sich diese anderen Cascade-Funktionen an:

* **[Workflows](./workflows)** - Automatisieren Sie wiederkehrende Aufgaben mit wiederverwendbaren Markdown-Workflows, die per Slash-Befehlen ausgelöst werden
* **[AGENTS.md](./agents-md)** - Stellen Sie verzeichnisspezifische Anweisungen bereit, die automatisch basierend auf dem Dateispeicherort angewendet werden
* **[Memories & Rules](./memories)** - Bewahren Sie Kontext über Unterhaltungen hinweg mit automatisch generierten Memories und benutzerdefinierten Regeln