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

# Skills

> Skills helfen Cascade, komplexe Aufgaben mit mehreren Schritten zu bewältigen.

Die anspruchsvollsten Engineering-Aufgaben erfordern oft mehr als nur gute Prompts. Sie benötigen unter Umständen Referenzskripte, Templates, Checklisten und andere unterstützende Dateien. Mit Skills können Sie all das in Ordnern bündeln, die Cascade aufrufen (lesen und verwenden) kann.

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

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

Weitere Informationen 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">
  ### In der UI (am einfachsten)
</div>

1. Öffnen Sie das Cascade-Panel
2. Klicken Sie oben rechts im Panel auf die drei Punkte, um das Menü „Customizations“ zu öffnen
3. Klicken Sie auf den Abschnitt `Skills`
4. Klicken Sie auf `+ Workspace`, um einen Workspace-Skill (projektspezifisch) zu erstellen, oder auf `+ Global`, um einen globalen Skill zu erstellen
5. Benennen Sie den Skill (nur Kleinbuchstaben, Zahlen und Bindestriche)

<div id="manual-creation">
  ### Manuell erstellen
</div>

**Workspace-Skill (projektspezifisch):**

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

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

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

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

Für jedes Skill ist eine `SKILL.md`-Datei mit YAML-Frontmatter erforderlich, 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**: Eindeutige Kennung für den Skill (wird in der UI angezeigt und für @-Erwähnungen verwendet)
* **description**: Kurze Erklärung, die dem Modell angezeigt wird, damit es entscheiden kann, 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">
  ## Unterstützende Ressourcen hinzufügen
</div>

Legen Sie alle unterstützenden Dateien im Skill-Ordner neben `SKILL.md` ab. Diese Dateien stehen Cascade zur Verfügung, 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">
  ### Automatischer Aufruf
</div>

Wenn deine Anfrage zur Beschreibung eines Skills passt, ruft Cascade den Skill automatisch auf und verwendet seine Anweisungen und Ressourcen, um die Aufgabe abzuschließen. Das ist die gebräuchlichste Art, wie Skills verwendet werden – du beschreibst einfach, was du tun möchtest, und Cascade entscheidet, 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 tut und wann er verwendet werden sollte.

<div id="manual-invocation">
  ### Manueller Aufruf
</div>

Sie können einen Skill jederzeit explizit aktivieren, indem Sie `@skill-name` im Cascade-Eingabefeld eingeben. Das ist nützlich, wenn Sie sicherstellen möchten, dass ein bestimmter Skill verwendet wird, oder wenn Sie einen Skill aufrufen möchten, der durch Ihre Anfrage möglicherweise nicht automatisch ausgelöst wird.

<div id="skill-scopes">
  ## Geltungsbereiche für Skills
</div>

| Geltungsbereich     | Speicherort                            | Verfügbarkeit                                                 |
| ------------------- | -------------------------------------- | ------------------------------------------------------------- |
| Workspace           | `.windsurf/skills/`                    | Nur im aktuellen Workspace. Wird 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 agentübergreifende Kompatibilität findet Devin Desktop Skills auch in `.agents/skills/` und `~/.agents/skills/`. Wenn Sie das Lesen von Claude-Code-Konfigurationen aktiviert haben, werden auch `.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 von Nutzern nicht 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, das eine `SKILL.md`-Datei enthält, genau wie Workspace-Skills.

<div id="example-use-cases">
  ## Beispielhafte Anwendungsfälle
</div>

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

Erstellen Sie einen Skill mit Deployment-Skripten, 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">
  ### Code-Review-Richtlinien
</div>

Nehmen Sie Styleguides, Sicherheitschecklisten und Review-Vorlagen auf:

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

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

Fassen Sie Testvorlagen, Anforderungen an die Testabdeckung und CI/CD-Konfigurationen zusammen:

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

<div id="best-practices">
  ## Bewährte Vorgehensweisen
</div>

1. **Schreiben Sie klare Beschreibungen**: Die Beschreibung hilft Cascade dabei zu entscheiden, wann der Skill eingesetzt werden soll. Beschreiben Sie möglichst genau, was der Skill tut und wann er verwendet werden sollte.

2. **Fügen Sie relevante Ressourcen hinzu**: Vorlagen, Checklisten und Beispiele machen Skills nützlicher. Überlegen Sie, welche Dateien dabei helfen würden, die Aufgabe abzuschließen.

3. **Verwenden Sie aussagekräftige Namen**: `deploy-to-staging` ist besser als `deploy1`. Namen sollten klar erkennen lassen, was der Skill tut.

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

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

|                            | Skills                                                                      | Rules                                                 | Workflows                                     |
| -------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------- | --------------------------------------------- |
| **Zweck**                  | Mehrstufige Verfahren mit Begleitdateien                                    | Verhaltensrichtlinien („wie man sich verhalten soll“) | Prompt-Vorlagen für wiederkehrende Aufgaben   |
| **Struktur**               | Ordner mit `SKILL.md` + beliebigen Ressourcendateien                        | Eine einzelne `.md`-Datei mit Frontmatter             | Eine einzelne `.md`-Datei                     |
| **Aufruf**                 | Das 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-Review- und Testverfahren, die Skripte/Vorlagen benötigen | Codestil, Projektkonventionen, Einschränkungen        | Einmalige Runbooks, die Sie explizit auslösen |

**Faustregel:** Wenn Cascade es automatisch aufgreifen soll *und* Begleitdateien benötigt, verwenden Sie Skills. Wenn es sich um eine kurze Verhaltensvorgabe handelt, verwenden Sie Rules. Wenn Sie es immer selbst auslösen möchten, verwenden Sie Workflows.

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

Wenn Skills nicht das Richtige für Sie sind, sehen Sie sich diese anderen Cascade-Funktionen an:

* **[Workflows](./workflows)** - Automatisieren Sie wiederkehrende Aufgaben mit wiederverwendbaren Markdown-Workflows, die über Slash-Befehle aufgerufen werden
* **[AGENTS.md](./agents-md)** - Stellen Sie verzeichnisbezogene Anweisungen bereit, die basierend auf dem Dateispeicherort automatisch angewendet werden
* **[Memories & Rules](./memories)** - Erhalten Sie Kontext über Unterhaltungen hinweg mit automatisch generierten Memories und nutzerdefinierten Regeln