KI-Pair-Programming mit IBM Bob

IBM Bob starten

Starte die IBM Bob IDE.

Bob-Chat-Oberfläche öffnen

Falls die Bob-Chat-Oberfläche nicht sichtbar ist, öffne sie, indem du das Bob-Symbol neben der Navigationsleiste auswählst. Du kannst auch Option + Command + B auf dem Mac oder Ctrl + Alt + B unter Windows und Linux drücken.

Leeren Projektordner öffnen

Erstelle einen leeren Ordner namens todo-api und öffne ihn in Bob mit Datei > Ordner öffnen. Falls Bob fragt, ob du den Autoren der Dateien im Ordner vertraust, wähle Ja, ich vertraue den Autoren.

Bob schreibt die generierte Anwendung in diesen Ordner. Für dieses Tutorial benötigst du kein vorhandenes Repository.

Auto-Genehmigung deaktivieren

Öffne Berechtigungen und bestätige, dass die Auto-Genehmigung deaktiviert ist. Mit deaktivierter Auto-Genehmigung bittet Bob um deine Erlaubnis, bevor es Dateien liest, Dateien bearbeitet oder Befehle ausführt. Du behältst in diesem Tutorial die Kontrolle über jede Änderung.

In den Plan-Modus wechseln

Öffne das Modus-Dropdown am unteren Rand der Bob-Seitenleiste und wähle Plan.

Modi wenden das Prinzip der minimalen Rechte an. Im Plan-Modus liest Bob deinen Code und schreibt einen Markdown-Plan. Bob führt keine Befehle aus und nimmt keine Implementierungsänderungen vor. Du überprüfst den Ansatz, bevor Bob Anwendungscode schreibt.

Anwendungsanforderungen definieren

Gib in der Bob-Chat-Oberfläche folgenden Prompt ein:

Create a simple FastAPI To-Do API.

Requirements:

- Store tasks in a Python list.
- Each task should contain:
    - id
    - task_name

Implement these endpoints with explicit HTTP status codes:

- GET /tasks: list all tasks. Return 200.
- POST /tasks: create a task from a JSON body containing only task_name. Return 201 with the created task.
- DELETE /tasks/{task_id}: delete a task. Return 204 on success and 404 if no task has that id.

Use FastAPI and Pydantic. Use Pydantic model validation so an invalid request body returns 422.

Include a requirements.txt and a Dockerfile. The Dockerfile must start Uvicorn bound to 0.0.0.0 on port 8000 so the API is reachable through a published container port.

Save the plan as Markdown files in a folder named `plans`.

Put the FastAPI application in a single file named `main.py` at the project root.

Keep the implementation simple.

Don't install any dependencies locally or run local tests. Everything will run in a Docker container.

Um den Plan zu erstellen, führt Bob seinen Planning-Skill aus. Wenn du dazu aufgefordert wirst, wähle Approve skill tools for task und Approve subagent tools for task, damit Bob den Workspace untersuchen und den Plan entwerfen kann.

Den Plan verfeinern

Du kannst den Plan ändern, bevor Bob Code schreibt. Gib in der Bob-Chat-Oberfläche einen Follow-up-Prompt ein:

Update the plan to reject a task whose task_name is empty or longer than 200 characters.

Bob überarbeitet den Plan, um die zusätzliche Eingabevalidierung einzuschließen. Überprüfe den aktualisierten Plan.

Den Plan überprüfen

Bob präsentiert einen geordneten Plan und speichert ihn möglicherweise als Markdown-Datei im Projekt. Überprüfe ihn, bevor du fortfährst:

• Umfang: Der Plan deckt jeden Endpunkt und die von dir hinzugefügte Validierungsregel ab – und nichts, wonach du nicht gefragt hast.
• Benannte Dateien: Jeder Schritt nennt die Datei, die er erstellt oder ändert.
• Vage Formulierungen: Formulierungen wie „Fehler angemessen behandeln“ verbergen Annahmen. Bitte Bob, diese zu präzisieren.

Du bleibst für diese Design-Entscheidungen verantwortlich. Bob implementiert nichts, bis du in Anwendung generieren und überprüfen in den Agent-Modus wechselst.

Ein neues Kontextfenster starten

Wähle Neue Aufgabe im Chat-Feld oder + oben im Chat-Panel, um ein frisches Kontextfenster zu starten. Siehe Ein neues Kontextfenster erstellen für Hintergrundinformationen. Bob hat den Plan im Ordner plans gespeichert, sodass du die Planungs-Konversation nicht mehr im Kontext benötigst. Ein sauberer Kontext hält die Implementierung auf den genehmigten Plan fokussiert.

In den Agent-Modus wechseln und den Plan ausführen

Öffne das Modus-Dropdown am unteren Rand der Bob-Seitenleiste und wähle Agent. Sage Bob dann, den Plan zu implementieren:

Implement the plan in the plans folder.
@plans/

Der Agent-Modus erlaubt es Bob, Dateien zu schreiben und Befehle auszuführen. Bob bittet vor jeder Änderung um Genehmigung, weil du die Auto-Genehmigung deaktiviert hast. Genehmige die Schritte, während Bob den Plan durcharbeitet.

Die generierte Anwendung überprüfen

Wenn die Implementierung abgeschlossen ist, überprüfe den generierten Code. Da Bobs Ausgabe probabilistisch ist, können dein Code-Stil und interne Namen von den hier gezeigten Beispielen abweichen. Die Anwendung besteht aus folgenden Teilen.

Datenmodelle. Bob generiert zwei Pydantic-Modelle: eines für den Request-Body beim Erstellen einer Aufgabe und eines für eine gespeicherte Aufgabe. Das Create-Modell erzwingt die Längenregel, die du beim Planen hinzugefügt hast:

class TaskCreate(BaseModel):
    task_name: Annotated[str, Field(min_length=1, max_length=200)]

class Task(BaseModel):
    id: int
    task_name: str

Die Endpunktpfade und Statuscodes stimmen mit den Anforderungen überein, die du Bob gegeben hast, aber Modellklassennamen und Dateistruktur können variieren. Dieses Tutorial setzt die Modelle Task und TaskCreate voraus. Passe die folgenden Prompts an, falls Bob andere Namen gewählt hat.

In-Memory-Datenspeicher. Bob speichert Aufgaben in einer leeren Python-Liste und weist jeder neuen Aufgabe eine inkrementierende id zu:

tasks: list[dict] = []
id_counter = 0

API-Operationen. Die Anwendung stellt folgende Endpunkte bereit:

• GET /tasks
• POST /tasks
• DELETE /tasks/{task_id}

POST /tasks akzeptiert nur task_name im Request-Body und gibt 201 mit der erstellten Aufgabe zurück. DELETE /tasks/{task_id} gibt 204 bei Erfolg und 404 zurück, wenn keine Aufgabe mit dieser task_id existiert.

Abhängigkeiten. Bob generiert eine requirements.txt-Datei, die FastAPI, Uvicorn und Pydantic auflistet.

Container. Bob generiert ein Dockerfile, das die Abhängigkeiten installiert und die API auf Port 8000 mit Uvicorn ausführt.

Der HTTP-Vertrag folgt dem Anforderungs-Prompt, einschließlich Methoden, Pfaden und Statuscodes. Die folgenden Validierungsschritte gelten wie beschrieben.

Die Anwendungsdatei öffnen

Öffne die von Bob generierte main.py-Datei und platziere deinen Cursor auf einer leeren Zeile am Ende der Datei, nach dem letzten Route-Handler.

Literate-Coding-Modus aktivieren

Drücke Command + I auf dem Mac oder Ctrl + I unter Windows und Linux. Du kannst auch das Zauberstab-Symbol in der Editor-Symbolleiste auswählen.

Die Anweisung schreiben

Gib die folgende Anweisung in die leere Zeile ein. Sie erscheint in einer anderen Farbe als der übrige Code hervorgehoben.

Add a PUT /tasks/{task_id} endpoint that updates the task_name of an existing task, matching the style and conventions of the existing routes. Return 200 with the updated task, or 404 if no task has that id.

Bob leitet den Parameternamen, das Request-Modell und die Fehlerbehandlung aus dem umgebenden Code ab, sodass du nur die Methode und den Pfad angeben musst.

Code generieren und akzeptieren

Wähle Generieren, oder drücke Command + Enter auf dem Mac oder Ctrl + Enter unter Windows und Linux. Bob ersetzt deine Anweisung durch eine Implementierung und zeigt einen Inline-Diff.

Überprüfe den Diff und wähle dann Alle akzeptieren, um die Änderung anzuwenden. Drücke erneut Command + I auf dem Mac oder Ctrl + I unter Windows und Linux, um den Literate-Coding-Modus zu verlassen.

Bob bitten, den Code zu erklären

Starte ein neues Kontextfenster mit Neue Aufgabe und wähle dann Ask aus dem Modus-Dropdown. Der Ask-Modus beantwortet Fragen und analysiert Code, ohne Dateien zu bearbeiten. Verwende ihn, wenn du eine Erklärung ohne Änderungen möchtest.

Das Verstehen von generiertem Code ist ein wichtiger Teil des KI-Pair-Programmings. Frage Bob:

Explain the generated To-Do API.

Bob kann die Anwendungsarchitektur, den Datenfluss, FastAPI-Komponenten, Pydantic-Modelle, Endpunktverhalten und Design-Entscheidungen erklären. Nutze die Erklärung, um zu bestätigen, dass der Code das tut, was du erwartest, bevor du ihn änderst oder erweiterst.

Die Anwendung ausführen

Wechsle zurück in den Agent-Modus, damit Bob Befehle ausführen kann. Bitte Bob, die API in einem Container zu bauen und auszuführen:

Build the Docker image and run the container with port 8000 mapped to the host. Confirm the API is reachable.

Bob führt die Build- und Startbefehle aus und meldet, wenn der Container läuft.

Öffne http://localhost:8000/docs in deinem Browser.

FastAPI stellt unter /docs eine interaktive Swagger-UI bereit. Nutze sie, um jeden Endpunkt zu erkunden, Request- und Response-Schemata zu inspizieren und API-Aufrufe direkt aus dem Browser durchzuführen.

Die API validieren

Nutze die Swagger-UI unter /docs, um jede Operation auszuprobieren. Für jeden Endpunkt:

1. Klappe die Zeile auf und wähle Try it out.
2. Gib etwaige Pfadparameter oder den Request-Body ein.
3. Wähle Execute.
4. Überprüfe den Server response-Code und -Body.

Eine Aufgabe hinzufügen

1. Klappe POST /tasks auf und wähle Try it out.

2. Ersetze den Request-Body durch:

   {
     "task_name": "My first API item!"
   }

3. Wähle Execute. Bestätige, dass der Response-Code 201 ist und der Response-Body die erstellte Aufgabe mit einer zugewiesenen id anzeigt.

Aufgaben abrufen

1. Klappe GET /tasks auf und wähle Try it out.
2. Wähle Execute. Bestätige, dass der Response-Code 200 ist und der Response-Body die Aufgabe My first API item! mit der beim Hinzufügen zugewiesenen id auflistet.

Eine Aufgabe aktualisieren

1. Klappe PUT /tasks/{task_id} auf und wähle Try it out.

2. Gib die task_id der erstellten Aufgabe ein.

3. Ersetze den Request-Body durch:

   {
     "task_name": "Build and ship a To-Do API"
   }

4. Wähle Execute. Bestätige, dass der Response-Code 200 ist und die zurückgegebene Aufgabe den aktualisierten task_name zeigt.

5. Ändere task_id auf einen nicht vorhandenen Wert und wähle erneut Execute. Bestätige, dass der Response-Code 404 ist.

Eine Aufgabe löschen

1. Klappe DELETE /tasks/{task_id} auf und wähle Try it out.
2. Gib die task_id der erstellten Aufgabe ein und wähle Execute. Bestätige, dass der Response-Code 204 ist.
3. Klappe GET /tasks auf, wähle Execute und bestätige, dass die Aufgabe nicht mehr in der Antwort erscheint.
4. Klappe DELETE /tasks/{task_id} erneut auf, gib dieselbe task_id ein und wähle Execute. Bestätige, dass der Response-Code 404 ist.

Die Implementierung erfüllt die ursprünglichen Anforderungen, einschließlich des mit Literate Coding hinzugefügten Update-Endpunkts.

Bob um Verbesserungsvorschläge bitten

Starte ein neues Kontextfenster mit Neue Aufgabe und gib dann ein:

Review the To-Do API and suggest improvements to code quality, error handling, and HTTP status codes.

Bob identifiziert Lücken wie einen fehlenden Endpunkt zum Abrufen einer einzelnen Aufgabe, einen In-Memory-Speicher, der einfache Dictionaries statt validierter Task-Modelle enthält, und einen id_counter auf Modulebene, der schwer zurückzusetzen oder zu testen ist.

Die Verbesserungen anwenden

Bitte Bob, die gewünschten Vorschläge zu implementieren:

Add a GET /tasks/{task_id} endpoint that returns 404 when the task ID does not exist, and store tasks as Task models instead of dictionaries.

Überprüfe die vorgeschlagenen Änderungen und genehmige sie, um sie anzuwenden. Bitte Bob, das Image neu zu bauen und den Container neu zu starten, und wiederhole dann die Validierungsschritte. Bestätige, dass GET /tasks/{task_id} bei einer gültigen ID 200 mit der Aufgabe und bei einer unbekannten ID 404 zurückgibt und dass die bestehenden Endpunkte weiterhin wie zuvor funktionieren.

Unit-Tests generieren

Starte ein neues Kontextfenster mit Neue Aufgabe und frage Bob dann:

Generate pytest unit tests for this application. Add pytest and httpx to a dev requirements file, build a test image, and run the suite in a container.

Bob fügt die pytest- und httpx-Testabhängigkeiten hinzu, baut ein Image, das diese enthält, führt die Suite in einem Container aus und berichtet die Ergebnisse. Das Ausführen der Tests in einem Container bedeutet, dass du keine lokale Python-Umgebung benötigst. Überprüfe und verfeinere die generierten Tests.

Das Überprüfen und Warten generierter Tests bleibt deine Verantwortung.

Technische Dokumentation generieren

Frage Bob:

Generate technical documentation for this To-Do API.

Bob kann eine Anwendungsübersicht, eine Architekturbeschreibung, Endpunktzusammenfassungen, Request- und Response-Beispiele sowie Verwendungsanweisungen generieren. Diese Dokumentation ergänzt die API-Dokumentation, die FastAPI automatisch generiert.