OpenClaw Skills erklärt: Community-Skills installieren und eigene schreiben

Was Skills eigentlich sind

Ohne Skills ist OpenClaw ein sehr höflicher Chatbot. Mit Skills ist es ein Assistent, der deinen Kalender liest, Code reviewed, Jira-Tickets erstellt und Slack-Nachrichten sendet.

Der Unterschied liegt in einer einzigen Datei: `SKILL.md`.

Ein Skill in OpenClaw ist kein Plugin im klassischen Sinne. Es gibt keine binäre Installation, keinen npm-Package-Manager, keine Versionskonflikte. Ein Skill ist eine Markdown-Datei, die dem Agenten erklärt:

1. Was dieser Skill kann (und wann er ihn benutzen soll)

2. Welche Scripts oder Tools er dafür aufrufen kann

3. Wie er die Ausgabe interpretieren soll

Das ist es. Der Agent liest das SKILL.md, versteht den Kontext, und weiß, was er wann benutzen kann.

In unserem 6-Agenten-Setup nutzen wir aktuell neun Skills — vier aus der Community, fünf selbst geschrieben. Dieser Post erklärt, wie beides funktioniert.

---

Skills installieren: Community-Skills aus Clawhub

Die schnellste Quelle für fertige Skills ist [clawhub.com](https://clawhub.com) — die Community-Plattform für OpenClaw-Skills. Dort findest du Skills für:

Schritt 1: Skill-Verzeichnis finden

OpenClaw lädt Skills aus einem konfigurierten Verzeichnis. Standardmäßig:

```bash

# Bundled Skills (mit OpenClaw mitgeliefert)

~/.npm-global/lib/node_modules/openclaw/skills/

# User Skills (deine eigenen und Community-Skills)

~/.openclaw/workspace/skills/

# oder

~/.agents/skills/

```

Prüfe, welches Verzeichnis dein Agent lädt:

```bash

openclaw config show | grep skills

```

Schritt 2: Community-Skill herunterladen

Jeder Clawhub-Skill hat ein GitHub-Repository. Installation:

```bash

# Skill-Verzeichnis erstellen falls nicht vorhanden

mkdir -p ~/.openclaw/workspace/skills

# Skill klonen (Beispiel: ClickUp-Skill)

git clone https://github.com/clawhub/skill-clickup ~/.openclaw/workspace/skills/clickup

# Oder: Nur das SKILL.md-Verzeichnis kopieren

cp -r /path/to/downloaded-skill ~/.openclaw/workspace/skills/clickup

```

Schritt 3: Konfiguration prüfen

Die meisten Skills brauchen einen API-Key oder Token. Das SKILL.md erklärt, welche Umgebungsvariablen nötig sind:

```bash

cat ~/.openclaw/workspace/skills/clickup/SKILL.md

# → zeigt: benötigt CLICKUP_API_TOKEN als env variable

```

Token zur .env-Datei hinzufügen:

```bash

echo 'CLICKUP_API_TOKEN=pk_...' >> ~/.openclaw/workspace/.env

```

Schritt 4: Gateway neu starten

```bash

openclaw gateway restart

```

Ab jetzt kennt der Agent den Skill. Beim nächsten Start liest er das SKILL.md und weiß: "Wenn ich mit ClickUp interagieren soll, benutze diesen Skill."

---

Welche Skills wir in unserem Setup nutzen

Für jeden Agenten haben wir Skills selektiv aktiviert — nach dem Prinzip des minimalen Privilegs (kein Agent hat Zugriff auf alles):

Sam (Teamleitung):

Peter (Coding):

Maya (Marketing):

Alex (Alltagsaufgaben):

Iris (Research):

Atlas (CEO-Assistent):

---

Einen eigenen Skill schreiben: Ein vollständiges Beispiel

Das Beste an OpenClaw-Skills: du brauchst keine Programmierung, um einen einfachen Skill zu schreiben. Du brauchst ein SKILL.md und optional ein Shell-Script.

Hier ist ein echter Skill, den wir für unser Setup geschrieben haben: Server-Health-Check.

Schritt 1: Verzeichnis anlegen

```bash

mkdir -p ~/.openclaw/workspace/skills/server-health

```

Schritt 2: Script schreiben

```bash

cat > ~/.openclaw/workspace/skills/server-health/check.sh << 'EOF'

#!/bin/bash

# Gibt Server-Gesundheitsdaten als JSON zurück

echo "{"

echo " \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\","

echo " \"uptime\": \"$(uptime -p)\","

echo " \"load\": \"$(cat /proc/loadavg | awk '{print $1, $2, $3}')\","

echo " \"memory\": {"

free -m | awk 'NR==2{printf " \"total\": %s, \"used\": %s, \"free\": %s", $2, $3, $4}'

echo ""

echo " },"

echo " \"disk\": {"

df -h / | awk 'NR==2{printf " \"total\": \"%s\", \"used\": \"%s\", \"available\": \"%s\", \"percent\": \"%s\"", $2, $3, $4, $5}'

echo ""

echo " },"

echo " \"docker_containers\": $(docker ps --format json | wc -l)"

echo "}"

EOF

chmod +x ~/.openclaw/workspace/skills/server-health/check.sh

```

Schritt 3: SKILL.md schreiben

Das ist das Herzstück. Das SKILL.md erklärt dem Agenten in natürlicher Sprache, was der Skill tut und wie er benutzt wird.

```markdown

# Server Health Check Skill

Wann benutzen

Benutze diesen Skill wenn:

Benutze diesen Skill NICHT für:

Wie benutzen

Führe das Script aus:

```bash

bash ~/.openclaw/workspace/skills/server-health/check.sh

```

Das Script gibt JSON zurück mit:

Interpretation

```

Schritt 4: Testen

Schick eine Nachricht an deinen Agenten:

"Kannst du den Server-Status prüfen?"

Der Agent liest das SKILL.md, erkennt dass er das check.sh-Script aufrufen soll, führt es aus, und interpretiert die JSON-Ausgabe in eine verständliche Antwort.

Erwartete Antwort:

"Server läuft gut. Uptime: 14 Tage.

CPU-Last: 0.8 (normal).

RAM: 3.1 GB von 8 GB genutzt (39%).

Disk: 42% belegt, noch 22 GB frei.

Alle 6 Docker-Container laufen."

---

Fortgeschrittener Skill: Mit API-Calls

Für Skills, die externe APIs aufrufen, sieht das Muster so aus:

```bash

# skills/clickup-daily/report.sh

#!/bin/bash

# Holt alle Tasks die heute fällig sind

API_TOKEN="${CLICKUP_API_TOKEN}"

TEAM_ID="${CLICKUP_TEAM_ID}"

TODAY=$(date +%s000) # Unix timestamp in ms

curl -s "https://api.clickup.com/api/v2/team/${TEAM_ID}/task" -H "Authorization: ${API_TOKEN}" -G --data-urlencode "due_date_lte=${TODAY}" --data-urlencode "include_closed=false" | python3 -c "

import json, sys

data = json.load(sys.stdin)

tasks = data.get('tasks', [])

print(f'Fällig heute: {len(tasks)} Tasks')

for t in tasks[:10]:

print(f'- [{t["status"]["status"]}] {t["name"]} (ID: {t["id"]})')

"

```

Das SKILL.md erklärt dann, dass diese Umgebungsvariablen gesetzt sein müssen (`CLICKUP_API_TOKEN`, `CLICKUP_TEAM_ID`) und wann der Agent dieses Script aufrufen soll.

---

Skills vs. direkte Tool-Nutzung: Wann was?

Eine häufige Frage: "Soll ich einen Skill schreiben oder dem Agenten einfach direkt die API-Dokumentation geben?"

Schreib einen Skill wenn:

Nutze direkte Tools wenn:

In der Praxis: Bundled OpenClaw-Tools für Standardaufgaben, eigene Skills für Business-spezifische Workflows.

---

Skill-Struktur für Klarheit

Eine bewährte Verzeichnisstruktur für Skills mit mehreren Scripts:

```

skills/clickup/

├── SKILL.md ← Haupt-Instruktionsdatei

├── scripts/

│ ├── list_tasks.sh ← Tasks auflisten

│ ├── create_task.sh ← Task erstellen

│ └── update_status.sh ← Status ändern

└── README.md ← Optionale menschenlesbare Doku

```

Das SKILL.md referenziert die Scripts:

```markdown

Tasks auflisten

```bash

bash ~/.openclaw/workspace/skills/clickup/scripts/list_tasks.sh --list-id LIST_ID

```

Task erstellen

```bash

bash ~/.openclaw/workspace/skills/clickup/scripts/create_task.sh --list LIST_ID --name "Task-Name" --priority 2

```

```

Der Agent liest das alles und weiß: "Wenn ich ClickUp-Tasks erstellen soll, benutze ich create_task.sh mit diesen Parametern."

---

Häufige Fehler beim Skill-Schreiben

Zu vage Anweisungen: "Benutze diesen Skill für ClickUp-Sachen" ist nicht hilfreich. Sei präzise: "Benutze diesen Skill wenn der Nutzer einen Task erstellen, Status ändern oder Tasks für heute abfragen möchte."

Fehlende Fehlerbehandlung: Scripts sollten immer einen Exit-Code zurückgeben und Fehler auf stderr ausgeben. Der Agent kann mit Fehlern umgehen — aber nur wenn er sie sieht.

Zu große SKILL.md-Dateien: Wenn das SKILL.md 500+ Zeilen hat, füllt es das Kontextfenster. Fokussiere auf das Wesentliche; detaillierte Dokumentation kommt in eine separate README.md.

Scripts ohne ausführbare Berechtigung:

```bash

chmod +x skills/mein-skill/script.sh

```

Vergisst man das: der Agent sieht "Permission denied" und weiß nicht, was er tun soll.

---

Das Ergebnis: Was Skills für unser Setup bedeuten

Bevor wir Skills hatten, musste der Agent bei jeder Aufgabe improvisieren: "Wie erstelle ich nochmal einen ClickUp-Task? Welches API-Format erwartet der?" Das führte zu Fehlern, Halluzinationen und inkonsistenten Ergebnissen.

Mit Skills: Der Agent liest das SKILL.md, kennt die Schritte, führt das Script aus, interpretiert das Ergebnis. Konsistent, schnell, zuverlässig.

Der Aufwand für ein einfaches Skill: 30–60 Minuten. Der Nutzen: jede Stunde, die der Agent diese Aufgabe danach selbst erledigt.

Die Skills, die wir in unserem 6-Agenten-Setup benutzen — inklusive der vollständigen SKILL.md-Dateien und Scripts für ClickUp, Outlook, GitHub und Discord — sind im OpenClaw Setup Playbook dokumentiert.

Komplett auf Deutsch verfügbar. 🇩🇪