/SKILL.md` ab. Devin findet sie automatisch in all Ihren verbundenen Repositories. Die vollständige Referenz zum Dateiformat finden Sie in der [Agent Skills specification](https://agentskills.io/specification).
## Warum Skills wichtig sind
Ohne Skills muss Devin in jeder Sitzung Workflows von Grund auf neu erschließen. Mit Skills definieren Sie einen Ablauf einmal, und Devin folgt ihm jedes Mal zuverlässig. Skills sind immer dann nützlich, wenn Sie einen Workflow haben, der:
* **Jedes Mal auf die gleiche Weise ausgeführt werden sollte** — Test-Checklisten, Bereitstellungsschritte, Review-Prozesse
* **Repo-spezifisches Wissen erfordert** — welche Services gestartet werden müssen, welche Ports zu verwenden sind, welche Befehle ausgeführt werden müssen
* **Von dynamischem Kontext profitiert** — Git-Diffs, Branchnamen oder Umgebungsinformationen, die beim Aufruf eingebunden werden
## Devin schlägt Skills automatisch vor
Devin kann Ihnen automatisch Skills vorschlagen. Nachdem Devin Ihre Anwendung getestet oder während einer Sitzung etwas Neues über Ihr Setup gelernt hat, schlägt es vor, einen Skill zu erstellen oder zu aktualisieren, um dieses Wissen festzuhalten. Sie sehen einen Vorschlag in Ihrer Sitzungs-Timeline mit:
* Einer Zusammenfassung dessen, was gelernt wurde (z. B. „how to start the backend with Docker“)
* Dem vorgeschlagenen Inhalt der Datei `SKILL.md`
* Einem **„Create PR“**-Button, um den Skill in Ihr Repo zu committen
Im Laufe der Zeit baut Devin in Ihrem Repo eine Bibliothek von Skills auf, die beschreiben, wie Ihre Anwendung ausgeführt, getestet und bereitgestellt wird.
## Beispiele
### Testen vor dem Öffnen einer PR
Ein Skill, der Devin vorgibt, wie eine Next.js-App vor dem Erstellen eines Pull Requests überprüft werden soll:
```markdown theme={null}
---
name: test-before-pr
description: Run the local dev server and verify pages before opening any PR that touches frontend code.
---
## Setup
1. Install dependencies: `npm install`
2. Start the database: `docker-compose up -d postgres`
3. Run migrations: `npx prisma migrate dev`
4. Start the dev server: `npm run dev`
5. Wait for "Ready on http://localhost:3000"
## Verify
1. Read the git diff to identify which pages changed
2. Open each affected page in the browser
3. Check for: console errors, layout issues, broken links
4. Screenshot each page at desktop (1280px) and mobile (375px) widths
## Before Opening the PR
1. Run `npm run lint` and fix any issues
2. Run `npm test` and confirm all tests pass
3. Include screenshots in the PR description
```
### Bereitstellen in einer Umgebung
Ein Skill, der die App mithilfe von Argumenten für die Zielumgebung bereitstellt, mit dynamischer Einfügung von Inhalten:
```markdown theme={null}
---
name: deploy
description: Deploy the app to a target environment and run smoke tests.
argument-hint:
triggers: ["user"]
---
## Deploy
1. Make sure you are on the correct branch for this deploy
2. Run `./scripts/deploy.sh $0`
3. Wait for the deploy script to complete successfully
## Verify
1. Curl `https://$0.example.com/health` and confirm a 200 response
2. Run the smoke test suite: `npm run test:smoke -- --env=$0`
3. Report the deployment URL and test results
## Current context
- Branch: !`git branch --show-current`
- Last commit: !`git log --oneline -1`
```
Der Aufruf mit `@skills:deploy staging` ersetzt `staging` durch `$ARGUMENTS` und `$0`, und die `` !`command` ``-Blöcke fügen aktuelle Git-Informationen ein. Das Feld `triggers: ["user"]` stellt sicher, dass Devin diesen Skill nur ausführt, wenn Sie ausdrücklich darum bitten — er wird nicht automatisch aktiviert.
### Untersuchung eines Teils der Codebasis
Ein Skill zur geführten Code-Exploration, der Devin auf schreibgeschützte Tools beschränkt:
```markdown theme={null}
---
name: investigate
description: Research a part of the codebase and produce a written summary with file references.
allowed-tools: Read, Grep, ListDir
argument-hint:
---
## Research
1. Search the codebase for files related to: $ARGUMENTS
2. Read the most relevant files thoroughly
3. Trace the call chain and data flow
## Summarize
1. Write a summary of how $ARGUMENTS works
2. Include specific file paths and line numbers for every claim
3. Note any concerns, edge cases, or areas that need attention
```
Das Feld `allowed-tools` beschränkt Devin auf schreibgeschützte Vorgänge — keine Änderungen, keine Shell-Befehle. Das ist nützlich für Erkundungsaufgaben, bei denen Sie Analysen ohne Seiteneffekte benötigen.
## Skill Discovery
Devin entdeckt Skills aus **zwei Quellen**, die zu Beginn jeder Session zusammengeführt werden:
1. **Indizierte Repos** — Das Backend von Devin indiziert `SKILL.md`-Dateien in allen Repositories, die mit deiner Organisation verbunden sind. Diese stehen sofort beim Start einer Session zur Verfügung, noch bevor Repos geklont werden.
2. **Geklonte Repos** — Sobald Repositories auf die Maschine der Session geklont werden, durchsucht Devin sie nach `SKILL.md`-Dateien auf dem Datenträger. Beim Scannen des Datenträgers gefundene Skills aktualisieren oder überschreiben passende indizierte Skills aus demselben Repo, sodass Devin immer die neueste Version auf dem jeweils bearbeiteten Branch verwendet.
Wenn ein Repo-Klon während einer laufenden Session fertiggestellt wird, scannt Devin dieses Repo automatisch erneut, damit neu hinzugefügte oder geänderte Skills ohne Neustart übernommen werden.
### Unterstützte Speicherorte für Skill-Dateien
Devin sucht nach `SKILL.md`-Dateien in allen folgenden Verzeichnissen:
* `.agents/skills//SKILL.md` **(empfohlen)**
* `.devin/skills//SKILL.md`
* `.github/skills//SKILL.md`
* `.claude/skills//SKILL.md`
* `.cursor/skills//SKILL.md`
* `.codex/skills//SKILL.md`
* `.cognition/skills//SKILL.md`
* `.windsurf/skills//SKILL.md`
Alle acht Pfade werden in jedem Repository durchsucht.
### Was Devin aus einer Skill-Datei lädt
Wenn eine Skill entdeckt wird, liest Devin das YAML-**Frontmatter** (den `---`-Block oben) ein und extrahiert:
| Field | Purpose |
| --------------- | ---------------------------------------------------------------------------------------------------------------- |
| `name` | Identifiziert die Skill. Fällt, falls ausgelassen, auf den Namen des übergeordneten Verzeichnisses zurück. |
| `description` | Kurze Zusammenfassung, die in der Skill-Liste angezeigt wird, damit Devin (und Sie) wissen, was die Skill macht. |
| `allowed-tools` | Beschränkt, welche Tools Devin verwenden kann, solange die Skill aktiv ist. |
Devin unterstützt außerdem diese zusätzlichen Frontmatter-Felder über die Standardspezifikation hinaus:
| Field | Purpose |
| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `argument-hint` | Hinweistext, der zusammen mit dem Skill-Namen angezeigt wird und die erwarteten Argumente beschreibt. |
| `triggers` | Steuert, wer die Skill aufrufen kann — standardmäßig `["user", "model"]`. Setzen Sie den Wert auf `["user"]`, um zu verhindern, dass Devin sie automatisch aktiviert. |
Alles **nach** dem Frontmatter ist der Skill-Body — die Schritt-für-Schritt-Anweisungen, denen Devin folgen soll, wenn die Skill aufgerufen wird.
Siehe die [Agent Skills specification](https://agentskills.io/specification) für eine vollständige Referenz des Dateiformats.
## Wie Devin Skills verwendet
Zu Beginn jeder Session sieht Devin eine Liste aller verfügbaren Skills (Name + Beschreibung). Wenn ein Skill **aufgerufen** wird, liest Devin die vollständige Datei `SKILL.md` und fügt deren Inhalt als Systemanweisung in seinen aktuellen Kontext ein. Das bedeutet, dass Devin die Schritte des Skills für den Rest der Aufgabe aktiv befolgt — es ist nicht nur eine Referenz, sondern steuert Devins Verhalten direkt.
Devin kann Skills auf verschiedene Arten verwenden:
### Automatischer Aufruf
Wenn Devin feststellt, dass ein Skill für die aktuelle Aufgabe relevant ist, wird er automatisch ausgeführt. Wenn du Devin zum Beispiel bittest, einen Bug im Frontend-Code zu beheben und es gibt einen `test-before-pr`-Skill, aktiviert Devin ihn, bevor der Pull Request (PR) eröffnet wird. Setze `triggers: ["user"]` im Frontmatter, um das automatische Ausführen für Skills zu verhindern, die du nur manuell auslösen möchtest.
### Erwähne einen Skill in deinem Prompt
Du kannst Devin anweisen, einen bestimmten Skill zu verwenden, indem du `@skills:skill-name` in deine Nachricht einfügst:
```
Fix the login bug on the /auth page @skills:test-before-pr
```
Sie können auch Argumente übergeben:
```
@skills:deploy staging
```
Im Skill-Body werden die Argumente überall dort eingesetzt, wo `$ARGUMENTS`, `$ARGUMENTS[0]`, `$1` usw. vorkommen.
### Nur eine aktive Fähigkeit gleichzeitig
Devin kann immer nur eine Fähigkeit gleichzeitig aktiv haben. Das Aufrufen einer neuen Fähigkeit ersetzt die vorherige. Wenn eine Fähigkeit aktiv ist, wird Devin dazu angeleitet, die Schritte dieser Fähigkeit der Reihe nach auszuführen und jeden Schritt abzuschließen, bevor er fortfährt.
### Suchen und Auflisten
Devin kann während einer Sitzung nach Skills anhand von Stichwort oder Verzeichnis suchen, wenn der passende Skill benötigt wird. Sie können Devin auch auffordern, die verfügbaren Skills aufzulisten oder sie neu zu laden, nachdem Sie Änderungen an einer Skill-Datei gepusht haben.
## Einschränkungen
* **Globale / organisationsweite Skills** — Aktuell befinden sich Skills innerhalb von Repositories. Für organisationsweite Skills kann als Workaround ein dediziertes „skills“-Repository erstellt werden. Wir arbeiten an nativer Unterstützung für organisationsweite Skills, die für alle Repositories gelten.
* **Kombinieren mehrerer Skills** — Derzeit kann immer nur ein Skill gleichzeitig aktiv sein. Wir arbeiten an Unterstützung für das Verketten und Kombinieren von Workflows.
## Skills vs. Playbooks
Sowohl Skills als auch [Playbooks](/de/product-guides/creating-playbooks) stellen Devin wiederverwendbare Anweisungen zur Verfügung, funktionieren aber unterschiedlich:
| | Skills | Playbooks |
| ------------------------- | ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| **Where they live** | In deinem Repo als `SKILL.md`-Dateien – versionsverwaltet zusammen mit deinem Code | In der Devin-Web-App – verwaltet über die UI |
| **How they're triggered** | Devin entdeckt und verwendet sie automatisch, oder du referenzierst sie in jedem Prompt mit `@skills:name` | Manuell an eine Sitzung angehängt, wenn du sie startest |
| **Scope** | Auf ein Repo begrenzt – Devin wählt die passenden Skills basierend auf den Repos aus, die für die Aufgabe relevant sind | Organisationsweit – jedes Teammitglied kann jedes Playbook an jede Sitzung anhängen |
| **Auto-suggestion** | Devin schlägt neue Skills vor, nachdem er deine App getestet oder etwas Neues gelernt hat | Manuell von Teammitgliedern erstellt |
| **Best for** | Testprozeduren, lokale Dev-Setups, Deployment-Checklisten, repo-spezifische Workflows | Wiederverwendbare Prompt-Vorlagen, repo-übergreifende Aufgabenmuster, Onboarding-Guides |
**Was sollte ich verwenden?** Wenn deine Anweisungen an ein bestimmtes Repo gebunden sind – also wie man es ausführt, testet oder bereitstellt –, verwende einen Skill. Wenn deine Anweisungen allgemeine Prompts sind, die über Repos oder Teams hinweg gelten, verwende ein Playbook.
## Weitere Informationen
* [Agent Skills specification](https://agentskills.io/specification) — der offene Standard für das `SKILL.md`-Dateiformat, Frontmatter-Felder und die Verzeichnisstruktur
* [Knowledge](/de/product-guides/knowledge) — für kontextuelle Tipps und Fakten (keine Schritt-für-Schritt-Anleitungen)
* [Playbooks](/de/product-guides/creating-playbooks) — für wiederverwendbare Prompt-Vorlagen, die Sitzungen zugeordnet sind