Kapseln und KI-Agenten in der Produktentwicklung

Kapseln in Aktion: Integration von KI-Agenten für Entwicklungsautomatisierung

KI-Agenten in der Produktentwicklung benötigen eine strikte Kontextstruktur. Kapseln bieten Expertenwissen in einem minimalistischen Format mit einsatzbereiten Werkzeugen und gewährleisten so eine vorhersehbare Generierung von Code und Architekturartefakten. Dies verhindert chaotische Architekturentwicklung bei sequenziellen Aufgaben.

Agentenmodi und die Rolle der Struktur

Agenten werden beim Prototyping und in der Produktentwicklung eingesetzt. Beim Prototyping liegt der Fokus auf schnellen Ergebnissen ohne Einschränkungen. In Produkten sind nicht-funktionale Anforderungen zwingend: Wartbarkeit, Lesbarkeit, Skalierbarkeit.

Ohne Struktur trifft ein Agent willkürliche Entscheidungen, was die Dienstuniformität beeinträchtigt. Eine Kapsel löst dies durch drei Komponenten:

• Expertenwissen: Verpackte Erfahrung ohne Raten.
• Minimalismus: Das Wesentliche ohne überflüssige Informationen für das Kontextfenster.
• Einsatzbereites Werkzeug: Methoden, Fähigkeiten, Schnittstellen für Agenten.

Zusätzlicher Projektkontext wird in AGENTS.md und CLAUDE.md gespeichert – Stilrichtlinien, Commit-Formate.

Wissenstransfer über MCP-Server

Expertenwissen wird über einen MCP-Server mit zwei Werkzeugen an den Agenten übertragen:

• Framework-Dokumentation: Prinzipien, Dienststruktur, BaseMethod-Muster, DI-Container, Events.
• archland.json-Dokumentation: Format, Füllregeln, C4-Diagramm-Generierung.

Die Trennung spart Tokens: Der Agent fordert das relevante Werkzeug an. Dokumente sind agentenorientiert – imperativer Stil, Regeln, Algorithmen.

Beispiel aus der nsc-toolkit-Framework-Dokumentation:

# nsc-toolkit Framework: Code-Generierungsleitfaden

Dieses Dokument ist als Satz von Regeln und Vorlagen
für die automatische Generierung korrekten Codes strukturiert.

## Framework-Kern: Methodenklasse (BaseMethod)

Implementierungsregeln:
- Deklarieren Sie eine statische settings-Eigenschaft,
  kopiert aus service.schema.json.
- Hauptlogik wird in der handler-Methode implementiert.
- Injizieren Sie Abhängigkeiten über den Konstruktor mit @inject-Decorator.
- Verwenden Sie this.logger für Logging.
- Verwenden Sie this.emitter für Event-Generierung.

REGEL: Erstellen Sie eine Methode für jeden RPC-Aufruf aus service.schema.json.
REGEL: Nur aktuelle und verwendete Abhängigkeiten sollten an den Container gebunden werden.

Algorithmus für archland.json:

Generierungsalgorithmus für jeden Dienst:

Schritt 1. Grundinformationen:
  - Lesen service.schema.json → Name, Beschreibung
  - Pfade schreiben: describePath, folderPath

Schritt 2. DI-Container-Analyse:
  - Lesen service.ts
  - Für jedes container.bind() ein Dependency-Objekt erstellen
  - Tags auf Typ und extern analysieren

Schritt 3. Methodenanalyse:
  - Für jede Klasse in methods/:
    service.schema.json für Beschreibung lesen
    Code auf Abhängigkeitsaufrufe und Event-Generierung analysieren

Schritt 4. Abonnementanalyse:
  - Für jede Klasse in processing/:
    DI-Schlüssel aus inversion.types.ts bestimmen
    start()-Methode analysieren, um Quelldienst zu bestimmen

Schritt 5. Alle Daten in ein einzelnes archland.json-Objekt sammeln

Praxis: Hinzufügen einer ListOrders-Methode

Szenario: Eine Methode zum Auflisten von Benutzerbestellungen im @services/order-Dienst mit Exposition über die HTTP-API.

Der Entwickler beschreibt das Datenformat. Der Agent generiert das Schema in service.schema.json:

"ListOrders": {
  "action": "ListOrders",
  "description": "Abrufen einer Liste von Benutzerbestellungen",
  "request": {
    "type": "object",
    "properties": {
      "credentials": {
        "type": "object",
        "properties": {
          "user_id":  { "type": "string" },
          "space_id": { "type": "string" }
        },
        "required": ["user_id", "space_id"]
      }
    },
    "required": ["credentials"]
  },
  "response": {
    "type": "object",
    "properties": {
      "result": {
        "type": "object",
        "properties": {
          "items": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "order_id":   { "type": "string" },
                "product_id": { "type": "string" },
                "quantity":   { "type": "number" },
                "created_at": { "type": "string" }
              },
              "required": ["order_id", "product_id", "quantity", "created_at"]
            }
          }
        }
      }
    },
    "required": ["result"]
  }
}

Prompt an den Agenten:

Erstellen Sie eine neue ListOrders-Methode im @services/order-Dienst.
Die Methode akzeptiert: user_id aus credentials.
Gibt zurück: eine Liste von Bestellungen, jede mit Feldern order_id, product_id, quantity, created_at.
Exponieren Sie die Methode in @services/gate im Endpunkt-Set @services/gate/routes/orders.ts.

Abfolge der Agentenaktionen:

• Liest CLAUDE.md → fordert MCP-Dokumentation an.
• Fügt Schema zu service.schema.json hinzu.
• Führt Code-Generierung mit Vorlagen durch.
• Implementiert Geschäftslogik mit @inject, Ports.
• Fügt HTTP-Endpunkt nach Muster hinzu.
• Bildet einen Commit gemäß Regeln.

Zeit: 10 Minuten. Die Vorlage ist für ähnliche Aufgaben reproduzierbar.

Generierung eines Architekturalbums

Prompt: Generieren Sie archland.json und das Architekturalbum des Projekts.

Der Agent ruft Dokumentation von MCP ab, durchläuft Dienste, analysiert Schemata, DI, Methoden, Abonnements. Sammelt Daten in archland.json mit C4-Diagrammen von Problembereichen. Der Prozess ist deterministisch basierend auf dem Algorithmus aus der Dokumentation.

Wichtige Erkenntnisse

• Kapseln bieten Struktur für Agenten in der Produktentwicklung.
• MCP-Server überträgt Expertenwissen über minimale Werkzeuge.
• Dokumentation ist imperativ: Regeln, Algorithmen, Vorlagen für Agenten.
• Aufgabenautomatisierung: Code-Generierung, HTTP-Endpunkte, Architekturalben in 10 Min.
• Vorhersehbarkeit: Einheitliche Architektur ohne chaotische Änderungen.

— Editorial Team