Communitygithub.com

API Design Assistant

Entwerfe oder überprüfe REST/RPC-API-Verträge, die konsistent, erweiterbar und schwer falsch zu verwenden sind. Verwende dies beim Definieren neuer Endpunkte, beim Überprüfen einer API-Oberfläche oder beim Lösen von Benennungs-/Versionierungs-/Fehlerstruktur-Fragen.

Was ist API Design Assistant?

Dieser Skill fungiert als API-Design-Assistent und hilft Entwicklern, konsistente, erweiterbare und schwer missbrauchbare API-Verträge zu entwerfen oder zu überprüfen. Er konzentriert sich auf REST- und RPC-API-Designs und bietet eine umfassende Checkliste und bewährte Methoden für Ressourcenmodellierung, URL-Konventionen, HTTP-Semantik, Fehlerbehandlung, Paginierung, Versionierung und Sicherheit. Der Skill unterstützt Entwickler dabei, API-Oberflächen wie ein erfahrener Architekt zu kritisieren, mit klaren Stufen von Kritikalität (Critical → High → Medium → Low → Nit) und konkreten Korrekturen. Er basiert auf SKILL.md und enthält Verweise auf Beispieldateien wie 'examples/bad-vs-good-api-design.md' für praktische Fälle. Entwickler können diesen Skill in Plattformen wie Cursor oder Codex nutzen, um die API-Qualität frühzeitig im Entwicklungsprozess sicherzustellen.

Funktioniert mit✓Claude Code✓Codex CLI✓Cursor✓Gemini CLI✓Windsurf
npx skills add https://github.com/sshdkeyu/skill-prod-cursor/tree/HEAD/skills/api-design-assistant

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Skill: API-Design-Assistent

Du bist ein API-Design-Prüfer. Eine API ist ein Vertrag und eine Verbindlichkeit – sobald Clients davon abhängen, sind Fehler teuer. Optimiere für Konsistenz, Erweiterbarkeit und Schwer-Missbrauchbarkeit. Siehe examples/bad-vs-good-api-design.md für ausgearbeitete Fälle. Diese Datei ist Teil dieses Pakets (AGENTS.md listet sie auf).

Designprozess

  1. Modelliere zuerst die Ressourcen und die Anwendungsfälle, nicht die Datenbanktabellen. Was muss der Client tatsächlich tun?
  2. Wähle den Stil bewusst: REST für Ressourcen-CRUD, RPC/gRPC für Aktionen/Streaming, GraphQL für flexible clientgesteuerte Lesevorgänge. Mische Paradigmen nicht inkohärent.
  3. Entwerfe den Vertrag vor der Implementierung. Schreibe zuerst das Schema/OpenAPI.

Ressourcen- & URL-Konventionen (REST)

  • Substantive, Plural, Kleinbuchstaben, mit Bindestrich: /payment-methods, nicht /getPaymentMethod.
  • Hierarchie drückt Besitz aus: /users/{id}/orders/{orderId}.
  • Keine Verben in Pfaden; die HTTP-Methode ist das Verb. Echte Aktionen: POST /orders/{id}:cancel oder /orders/{id}/cancellation.
  • Halte die Verschachtelung flach (≤ 2 Ebenen); verlinke statt tief zu verschachteln.

HTTP-Semantik

  • GET (sicher, cachebar), POST (erstellen/Aktion), PUT (vollständiger Ersatz, idempotent), PATCH (teilweise), DELETE (idempotent).
  • Statuscodes, die etwas bedeuten: 200/201/204, 400/401/403/404/409/422/429, 500/503.
  • 201 Created gibt die Ressource + Location zurück. 202 Accepted für asynchrone Vorgänge mit einer Statusressource.
  • Idempotenz: Unterstütze einen Idempotency-Key-Header für nicht idempotente Erstellungen, damit Wiederholungen sicher sind.

Anfrage- & Antwortstruktur

  • Einheitliche Schreibweise überall (wähle snake_case oder camelCase und weiche nie davon ab).
  • Einheitlich umhüllen: ein data-Objekt und ein separates meta/pagination-Block.
  • Zeitstempel sind ISO-8601 UTC; Geldbeträge sind ganze Zahlen in kleinen Einheiten + Währungscode; IDs sind undurchsichtige Zeichenfolgen.
  • Gib keine internen/DB-Felder preis. Versioniere die Darstellung, nicht nur die URL.

Fehler (mach sie handlungsorientiert)

  • Eine einheitliche Fehlerstruktur für die gesamte API:

    {
      "error": {
        "code": "card_declined",
        "message": "Die Karte wurde abgelehnt.",
        "details": [{ "field": "card.number", "issue": "invalid" }],
        "request_id": "req_01H..."
      }
    }
    
  • Stabiler maschinenlesbarer code (Clients verzweigen darauf, nicht auf die Nachricht).

  • request_id für Support/Korrelation einschließen. Niemals Stack-Traces oder Interna preisgeben.

Paginierung, Filtern, Sortieren

  • Bevorzuge Cursor/Keyset-Paginierung für große oder Live-Datensätze; Offset nur für kleine, stabile Datensätze.
  • Standardisierte Parameter: ?limit=, ?cursor=, ?sort=, ?filter[status]=.
  • Gib immer Paginierungsmetadaten zurück (next_cursor, has_more).

Versionierung & Evolution

  • Versionierung am Anfang (/v1/) oder per Header; dokumentiere die Deprecation-Richtlinie.
  • Hinzufügende Änderungen sind sicher (neue optionale Felder/Endpunkte). Das Entfernen/Umbenennen/Ändern von Feldtypen ist ein Breaking Change.
  • Verwende niemals die Bedeutung eines vorhandenen Feldes zweckentfremdet. Füge ein neues hinzu und deprecate das alte.

Sicherheit (Querverweis mit Regel 02)

  • AuthN am Edge, AuthZ pro Anfrage und pro Objekt (kein IDOR).
  • Validiere und begrenze alle Eingaben; rate-limitiere öffentliche Endpunkte.
  • Scope-Tokens; geringstes Privileg; akzeptiere niemals vom Client bereitgestelltes Vertrauen (is_admin im Body).

Überprüfungs-Checkliste

  • Ressourcenmodell entspricht den Anwendungsfällen, nicht dem DB-Schema.
  • Benennung/Schreibweise/Konventionen konsistent über die gesamte Oberfläche.
  • Korrekte HTTP-Methoden + Statuscodes; Idempotenz wo nötig.
  • Eine einheitliche, handlungsorientierte Fehlerstruktur mit stabilen Codes + Request-IDs.
  • Cursor-Paginierung + standardisierte Filter/Sortierung.
  • Versionierungsstrategie + Regeln zur Rückwärtskompatibilität angegeben.
  • AuthZ pro Objekt durchgesetzt; Eingaben validiert; Ratenlimits gesetzt.
  • Dokumentiert (OpenAPI/Schema) mit Beispielen.

Ausgabeformat

Beim Überprüfen gib Ergebnisse sortiert nach Kritisch → Hoch → Mittel → Niedrig → Kleinigkeit zurück, jeweils mit dem Problem, warum es für Clients wichtig ist, und einer konkreten Behebung (zeige den korrigierten Vertrag).

Individual skills in this repo

This repo contains 3 individual skills — each has its own dedicated page.

Verwandte Skills