Dem Agent ein „Fachgehirn“ verleihen: So schreiben Sie benutzerdefinierte Agent Skills für Antigravity

Letzte Woche fragte mich ein Teammitglied zum x-ten Mal: „Wie funktioniert der Authentifizierungsflow dieser API eigentlich?”

Ich öffnete die verstaubte Confluence-Seite – letzte Aktualisierung vor sechs Monaten. Dokumentation und Code waren wieder out of sync. Seufzend tippte ich die Erklärung ab, die ich schon unzählige Male gegeben hatte.

Abends experimentierte ich mit Antigravity und stieß dabei auf das Skills-System. Kurz gesagt: Sie können dem KI-Agent ein „Fachgehirn” einpflanzen – spezifisches Wissen, feste Abläufe, definierte Werkzeuge.

Zwei Stunden später hatte ich einen Skill für unsere interne API. Am nächsten Tag stellte ein Neuer dieselbe Frage – ich tippte in Antigravity: „Schau nach, wie der Authentifizierungsflow unseres User-Services funktioniert.”

Der Agent rief meinen Skill auf; nach dreißig Sekunden kam eine präzise Erklärung mit Codebeispielen. Der Neue nickte und legte selbst los.

In dem Moment wurde mir klar: Das Skill-System ist mehr als eine Erweiterung – es verändert, wie Teams zusammenarbeiten.

Dieser Artikel erklärt, wie Sie eigene Skills für Antigravity schreiben – von den Grundlagen bis zu Praxisbeispielen, inklusive externer APIs und privater Wissensbasen.

Was sind Antigravity Skills

Zuerst die Begriffe klären.

Das Skill-System von Antigravity ist ein leichtgewichtiges, offenes Erweiterungsformat. Stellen Sie es sich als „Apps” für den KI-Agent vor – jeder Skill definiert bestimmte Fähigkeiten, damit der Agent in passenden Situationen professioneller wirkt.

Laut Google Codelabs sind Skills Verzeichnispakete in standardisiertem Format, die der Agent zuverlässig parsen und ausführen kann. Ein typischer Skill enthält:

KiloClaw - Managed OpenClaw für Unternehmen: AI-Agent-Orchestrierung und smartes Modell-Routing

Jetzt starten →Anzeige

• skill.yaml: Metadaten, Fähigkeitsbeschreibung, Einsatzszenarien
• README.md: Ausführliche Funktions- und Nutzungsbeschreibung
• scripts/: Ausführbare Skripte (Python, Bash usw.)
• templates/: Prompt- oder Ausgabe-Templates

Skills lassen sich in zwei Gültigkeitsbereichen definieren:

• Global (~/.gemini/antigravity/skills/): projektübergreifend, z. B. „JSON formatieren”, „generisches Code-Review”
• Projekt (.agent/skills/): nur im aktuellen Projekt, z. B. „API-Richtlinien unseres Teams”, „domänenspezifische Code-Templates”

Praktische Aufteilung: Allgemeines global, Geschäftliches im Projekt.

Ihren ersten Skill schreiben

Jetzt wird es praktisch.

Wir starten mit einem einfachen Beispiel: ein Skill, der Git-Commit-Messages automatisch formatiert.

Schritt 1: Verzeichnisstruktur anlegen

mkdir -p ~/.gemini/antigravity/skills/git-commit-formatter

Schritt 2: skill.yaml schreiben

name: git-commit-formatter
description: Format Git commit messages following Conventional Commits spec
version: 1.0.0
author: your-name
triggers:
  - commit
  - git message
  - format commit
actions:
  - name: format_commit
    description: Format a raw commit message to Conventional Commits format
    input:
      raw_message: string
      type: enum[feat, fix, docs, style, refactor, test, chore]
    output:
      formatted_message: string

Dieses YAML definiert Basisinformationen, Auslöse-Keywords sowie Ein- und Ausgabeformat.

Schritt 3: Ausführungsskript schreiben

Im Verzeichnis scripts/format_commit.py anlegen:

#!/usr/bin/env python3
import sys
import re

def format_commit(raw_message, commit_type):
    # Ursprüngliche Nachricht parsen
    scope_match = re.search(r'\(([^)]+)\)', raw_message)
    scope = f"({scope_match.group(1)})" if scope_match else ""

    # Beschreibung extrahieren
    desc = re.sub(r'\([^)]+\):?\s*', '', raw_message).strip()

    # Formatieren
    formatted = f"{commit_type}{scope}: {desc}"
    return formatted

if __name__ == "__main__":
    raw = sys.argv[1]
    ctype = sys.argv[2]
    print(format_commit(raw, ctype))

Schritt 4: Testen

Antigravity neu starten und eingeben:

„Formatiere diese Commit-Message mit git-commit-formatter: Bug beim User-Login behoben”

Funktioniert alles, ruft der Agent Ihren Skill auf und liefert z. B.: fix(auth): Bug beim User-Login behoben

Einfach – das ist das Grundgerüst eines Skills.

Externe APIs integrieren: GitHub + Jira in der Praxis

Ein lokaler Skill allein ist ein Spielzeug – wirklich nützlich werden Skills, die externe Systeme anbinden.

Als Nächstes: ein Skill, der Jira-Tickets automatisch bearbeitet.

Szenario: Das Team verbringt täglich viel Zeit in Jira – Status aktualisieren, Arbeitszeit erfassen. Der Agent übernimmt diese Routine.

Schritt 1: API-Authentifizierung vorbereiten

Sie brauchen Jira-API-Token und Domain. Sensible Daten am besten als Umgebungsvariablen:

export JIRA_API_TOKEN="your-token"
export JIRA_DOMAIN="your-domain.atlassian.net"
export JIRA_EMAIL="[email protected]"

Schritt 2: Skill-Konfiguration schreiben

name: jira-assistant
description: Automate Jira workflows - search issues, update status, add worklogs
triggers:
  - jira
  - ticket
  - issue
  - worklog
actions:
  - name: search_issues
    description: Search Jira issues by JQL query
  - name: add_worklog
    description: Add time spent to an issue
  - name: transition_issue
    description: Move issue to a different status

Schritt 3: Kernskript schreiben

#!/usr/bin/env python3
import os
import requests
from base64 import b64encode

class JiraClient:
    def __init__(self):
        self.domain = os.getenv('JIRA_DOMAIN')
        self.email = os.getenv('JIRA_EMAIL')
        self.token = os.getenv('JIRA_API_TOKEN')
        self.auth = self._get_auth()

    def _get_auth(self):
        credentials = f"{self.email}:{self.token}"
        return b64encode(credentials.encode()).decode()

    def search(self, jql):
        url = f"https://{self.domain}/rest/api/2/search"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        response = requests.get(url, headers=headers, params={"jql": jql})
        return response.json()

    def add_worklog(self, issue_key, time_spent, comment):
        url = f"https://{self.domain}/rest/api/2/issue/{issue_key}/worklog"
        headers = {
            "Authorization": f"Basic {self.auth}",
            "Content-Type": "application/json"
        }
        data = {
            "timeSpent": time_spent,
            "comment": comment
        }
        return requests.post(url, headers=headers, json=data)

# CLI-Einstieg
if __name__ == "__main__":
    import sys
    client = JiraClient()

    if sys.argv[1] == "search":
        result = client.search(sys.argv[2])
        for issue in result.get('issues', []):
            print(f"{issue['key']}: {issue['fields']['summary']}")

    elif sys.argv[1] == "worklog":
        client.add_worklog(sys.argv[2], sys.argv[3], sys.argv[4])
        print(f"Worklog added to {sys.argv[2]}")

Schritt 4: Nutzung

In Antigravity können Sie sagen:

„Zeig mir alle Jira-Tickets, die bei mir In Progress sind”

„Trage 2 Stunden auf PROJ-123 ein, Kommentar: User-Modul-Refactoring abgeschlossen”

„Setze PROJ-456 auf Done”

Der Agent ruft die Jira-API auf – ohne die träge Jira-Oberfläche.

Alibaba Cloud - Top-Wahl für Entwickler, exklusiv 15 % Rabatt auf Lighthouse-Server

15 % Rabatt sichern →Anzeige

Die GitHub-Integration funktioniert ähnlich: PyGithub oder direkte requests-Aufrufe. Skills können PRs erstellen, CI-Status prüfen oder Code-Reviews unterstützen.

Private Wissensbasis anbinden: NotebookLM + Antigravity

Das ist der spannendste Teil.

Auf XDA Developers beschreibt ein Autor einen interessanten Fall: Projektdokumentation in NotebookLM, daraus technische Spezifikationen, dann Umwandlung in Antigravity Skills – der Agent schreibt Code auf Basis der Projektdokumente.

Umsetzungsidee:

NotebookLM kann Dialoge als strukturierte Dokumente exportieren. Vorgehen:

1. Projektwissensbasis in NotebookLM anlegen (Design, API-Spezifikationen, Architekturentscheidungen)
2. Mit NotebookLM-Q&A eine „Wissenszusammenfassung” erstellen
3. Zusammenfassung in Skill-context oder -templates überführen

Oder direkter: NotebookLM per MCP (Model Context Protocol) mit Antigravity verbinden.

Das Open-Source-Projekt notebooklm-antigravity-skill auf GitHub bindet die Integration über die nlm CLI ein:

name: notebooklm-knowledge
description: Query project knowledge from NotebookLM
triggers:
  - dokumentation
  - spezifikation
  - projektwissen
actions:
  - name: query_knowledge
    description: Query NotebookLM for project-specific knowledge

Mit einem Skript, das die NotebookLM-API aufruft, kann der Agent Ihre private Wissensbasis live abfragen.

Stellen Sie sich vor:

Neuer Mitarbeiter: „Wie lauten unsere Fehlerbehandlungs-Richtlinien?”
Sie: (in Antigravity) „Schau in NotebookLM nach den Fehlerbehandlungs-Richtlinien”
Agent: „Laut Projektdokumentation: 1. Eigene Exception-Klassen verwenden … 2. Logs müssen Traceback enthalten … 3. Nutzer sichtbare Fehler internationalisieren …”

Dokumentation liegt nicht mehr in der Schublade – sie wird zum „Fachgehirn” des Agents.

Fortgeschritten: Rules und Skills kombinieren

Neben Skills gibt es bei Antigravity ein „Rules”-System. Zusammen sind sie deutlich mächtiger.

Rules sind globale oder projektbezogene Verhaltensvorgaben, z. B.:

# .agent/rules/code-review.md

Beim Code-Review:
1. Ausreichende Unit-Test-Abdeckung prüfen
2. Keine hardcodierten sensiblen Daten
3. Fehlerbehandlung vollständig
4. Einhaltung der TypeScript-Richtlinien des Teams

Rules definieren wann und nach welchen Kriterien gehandelt wird; Skills definieren wie ausgeführt wird.

Railway - Moderne Deployment-Plattform, ohne DevOps-Aufwand, in Minuten live

Jetzt starten →Anzeige

Atlassian-Entwickler beschreiben in einem Blogbeitrag einen Praxisfall: app-deployment-Rule plus Jira-Skills für automatisierte Deployments.

Wenn der Agent erkennt, dass Code in den main-Branch gemergt wurde:

1. Rule löst aus: „Pre-Deployment-Checks ausführen”
2. Skill: Jira-Ticket-Status prüfen
3. Skill: Test-Suite ausführen
4. Skill: Bei Erfolg Jira-Status aktualisieren und Deployment protokollieren

Ein Workflow mit dutzenden manuellen Schritten – per Satz auslösbar.

Fazit

Kurz gesagt: Skills machen aus Antigravity einem Allzweckwerkzeug einen Fachassistenten.

Allgemeine KI kann Code schreiben, kennt aber Ihr Geschäft nicht. Mit Skills pflanzen Sie Domänenwissen, Teamstandards und interne Tools ein – der Agent wird zum Teammitglied.

Vom ersten Git-Commit-Formatter bis heute: über zwanzig interne Skills – API-Dokumentation, Code-Standards, Jira-Tickets, sogar Onboarding. Routinearbeit wandert zum Agent.

Nicht aus Faulheit – damit Energie in Wertvolles fließt: Architektur, schwierige Probleme, neue Produkte. Wiederholte Wissensabfragen und Prozesse? Überlassen Sie sie dem Agent.

Starten Sie mit einem kleinen Schmerzpunkt: die Frage, die Ihr Team ständig stellt, oder den Ablauf, den Sie zehnmal täglich wiederholen. Ein Skill kann das lösen.

Der Agent ist mehr als ein Werkzeug – er ist eine Erweiterung Ihres Teams.

Und Skills sind der Schlüssel zu seiner Fachkompetenz.