Programmation en binôme avec l'IA et IBM Bob

Lancer IBM Bob

Lance l'application IBM Bob.

Ouvrir l'interface de chat Bob

Si l'interface de chat Bob n'est pas visible, ouvre-la en sélectionnant l'icône Bob à côté de la barre de navigation. Tu peux aussi appuyer sur Option + Command + B sur Mac, ou Ctrl + Alt + B sur Windows et Linux.

Ouvrir un dossier de projet vide

Crée un dossier vide nommé todo-api, puis ouvre-le dans Bob avec Fichier > Ouvrir le dossier. Si Bob te demande si tu fais confiance aux auteurs des fichiers du dossier, sélectionne Oui, je fais confiance aux auteurs.

Bob écrit l'application générée dans ce dossier. Tu n'as pas besoin d'un dépôt existant pour ce tutoriel.

Désactiver l'approbation automatique

Ouvre Permissions et confirme que l'approbation automatique est désactivée. Avec l'approbation automatique désactivée, Bob demande ta permission avant de lire des fichiers, de modifier des fichiers ou d'exécuter des commandes. Tu gardes le contrôle de chaque modification dans ce tutoriel.

Passer en mode Plan

Ouvre le menu déroulant des modes en bas de la barre latérale de Bob et sélectionne Plan.

Les modes appliquent le principe du moindre privilège. En mode Plan, Bob lit ton code et rédige un plan Markdown. Bob n'exécute pas de commandes et n'apporte pas de modifications d'implémentation. Tu révises l'approche avant que Bob écrive du code d'application.

Définir les exigences de l'application

Dans l'interface de chat Bob, entre le prompt suivant :

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.

Pour construire le plan, Bob exécute son skill de planification. Quand cela t'est demandé, sélectionne Approve skill tools for task et Approve subagent tools for task pour que Bob puisse explorer l'espace de travail et rédiger le plan.

Affiner le plan

Tu peux modifier le plan avant qu'un code soit écrit. Dans l'interface de chat Bob, entre un prompt de suivi :

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

Bob révise le plan pour inclure la validation d'entrée supplémentaire. Révise le plan mis à jour.

Réviser le plan

Bob présente un plan ordonné et peut le sauvegarder sous forme de fichier Markdown dans le projet. Révise-le avant de continuer :

• Périmètre : le plan couvre chaque endpoint et la règle de validation que tu as ajoutée, et rien que tu n'as pas demandé.
• Fichiers nommés : chaque étape nomme le fichier qu'elle crée ou modifie.
• Langage vague : des phrases comme « gérer les erreurs de manière appropriée » cachent des hypothèses. Demande à Bob de les préciser.

Tu restes responsable de ces décisions de conception. Bob n'implémente rien avant que tu passes en mode Agent dans Générer et réviser l'application.

Démarrer une nouvelle fenêtre de contexte

Sélectionne Nouvelle tâche dans la zone de chat ou + en haut du panneau de chat pour démarrer une nouvelle fenêtre de contexte. Consulte Créer une nouvelle fenêtre de contexte pour plus de contexte. Bob a sauvegardé le plan dans le dossier plans, donc tu n'as plus besoin de la conversation de planification dans le contexte. Un contexte propre garde l'implémentation focalisée sur le plan approuvé.

Passer en mode Agent et exécuter le plan

Ouvre le menu déroulant des modes en bas de la barre latérale de Bob et sélectionne Agent. Puis dis à Bob d'implémenter le plan :

Implement the plan in the plans folder.
@plans/

Le mode Agent permet à Bob d'écrire des fichiers et d'exécuter des commandes. Bob demande une approbation avant chaque modification car tu as désactivé l'approbation automatique. Approuve les étapes au fur et à mesure que Bob avance dans le plan.

Réviser l'application générée

Lorsque l'implémentation est terminée, révise le code généré. Étant donné que la sortie de Bob est probabiliste, ton style de code et tes noms internes peuvent différer des exemples présentés ici. L'application se compose des parties suivantes.

Modèles de données. Bob génère deux modèles Pydantic : un pour le corps de la requête lors de la création d'une tâche, et un pour une tâche stockée. Le modèle de création applique la règle de longueur que tu as ajoutée lors de la planification :

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


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

Les chemins d'endpoints et les codes de statut correspondent aux exigences que tu as données à Bob, mais les noms de classes de modèles et la structure des fichiers peuvent varier. Ce tutoriel suppose les modèles Task et TaskCreate. Adapte les prompts suivants si Bob a choisi des noms différents.

Magasin de données en mémoire. Bob stocke les tâches dans une liste Python vide et attribue à chaque nouvelle tâche un id incrémental :

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

Opérations API. L'application fournit les endpoints suivants :

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

POST /tasks prend uniquement task_name dans le corps de la requête et retourne 201 avec la tâche créée. DELETE /tasks/{task_id} retourne 204 en cas de succès et 404 lorsqu'aucune tâche n'a ce task_id.

Dépendances. Bob génère un fichier requirements.txt qui liste FastAPI, Uvicorn et Pydantic.

Conteneur. Bob génère un Dockerfile qui installe les dépendances et exécute l'API sur le port 8000 avec Uvicorn.

Le contrat HTTP suit le prompt des exigences, y compris les méthodes, les chemins et les codes de statut. Les étapes de validation suivantes s'appliquent telles qu'elles sont écrites.

Ouvrir le fichier de l'application

Ouvre le fichier main.py que Bob a généré et place ton curseur sur une ligne vide à la fin du fichier, après le dernier gestionnaire de route.

Activer le mode de codage littéraire

Appuie sur Command + I sur Mac, ou Ctrl + I sur Windows et Linux. Tu peux aussi sélectionner l'icône de baguette magique dans la barre d'outils de l'éditeur.

Écrire l'instruction

Entre l'instruction suivante sur la ligne vide. Elle apparaît surlignée dans une couleur différente du reste du code.

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 déduit le nom du paramètre, le modèle de requête et la gestion des erreurs du code environnant, donc tu n'as qu'à spécifier la méthode et le chemin.

Générer et accepter le code

Sélectionne Générer, ou appuie sur Command + Enter sur Mac, ou Ctrl + Enter sur Windows et Linux. Bob remplace ton instruction par une implémentation et affiche un diff en ligne.

Révise le diff, puis sélectionne Tout accepter pour appliquer la modification. Appuie à nouveau sur Command + I sur Mac, ou Ctrl + I sur Windows et Linux pour quitter le mode de codage littéraire.

Demander à Bob d'expliquer le code

Démarre une nouvelle fenêtre de contexte avec Nouvelle tâche, puis sélectionne Ask dans le menu déroulant des modes. Le mode Ask répond aux questions et analyse le code sans modifier les fichiers. Utilise-le quand tu veux une explication sans modifications.

Comprendre le code généré est une partie importante de la programmation en binôme avec l'IA. Demande à Bob :

Explain the generated To-Do API.

Bob peut expliquer l'architecture de l'application, le flux de données, les composants FastAPI, les modèles Pydantic, le comportement des endpoints et les décisions de conception. Utilise l'explication pour confirmer que le code fait ce que tu attends avant de le modifier ou de l'étendre.

Exécuter l'application

Repasse en mode Agent pour que Bob puisse exécuter des commandes. Demande à Bob de construire et d'exécuter l'API dans un conteneur :

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

Bob exécute les commandes de construction et de démarrage et signale quand le conteneur est en cours d'exécution.

Ouvre http://localhost:8000/docs dans ton navigateur.

FastAPI sert une interface Swagger UI interactive à /docs. Utilise-la pour explorer chaque endpoint, inspecter les schémas de requête et de réponse, et exécuter des appels API depuis le navigateur.

Valider l'API

Utilise l'interface Swagger UI à /docs pour exercer chaque opération. Pour chaque endpoint :

1. Développe sa ligne et sélectionne Try it out.
2. Entre les paramètres de chemin ou le corps de requête.
3. Sélectionne Execute.
4. Vérifie le code et le corps de la Server response.

Ajouter une tâche

1. Développe POST /tasks et sélectionne Try it out.

2. Remplace le corps de la requête par :

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

3. Sélectionne Execute. Confirme que le code de réponse est 201 et que le corps de la réponse affiche la tâche créée avec un id attribué.

Récupérer les tâches

1. Développe GET /tasks et sélectionne Try it out.
2. Sélectionne Execute. Confirme que le code de réponse est 200 et que le corps de la réponse liste la tâche My first API item! avec l'id attribué lors de son ajout.

Mettre à jour une tâche

1. Développe PUT /tasks/{task_id} et sélectionne Try it out.

2. Entre le task_id de la tâche que tu as créée.

3. Remplace le corps de la requête par :

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

4. Sélectionne Execute. Confirme que le code de réponse est 200 et que la tâche retournée affiche le task_name mis à jour.

5. Modifie task_id pour une valeur qui n'existe pas et sélectionne à nouveau Execute. Confirme que le code de réponse est 404.

Supprimer une tâche

1. Développe DELETE /tasks/{task_id} et sélectionne Try it out.
2. Entre le task_id de la tâche que tu as créée et sélectionne Execute. Confirme que le code de réponse est 204.
3. Développe GET /tasks, sélectionne Execute, et confirme que la tâche n'apparaît plus dans la réponse.
4. Développe à nouveau DELETE /tasks/{task_id}, entre le même task_id, et sélectionne Execute. Confirme que le code de réponse est 404.

L'implémentation satisfait les exigences initiales, y compris l'endpoint de mise à jour que tu as ajouté avec le codage littéraire.

Demander à Bob des suggestions d'amélioration

Démarre une nouvelle fenêtre de contexte avec Nouvelle tâche, puis entre :

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

Bob identifie des lacunes telles qu'un endpoint manquant pour récupérer une seule tâche, un magasin en mémoire qui contient des dictionnaires simples plutôt que des modèles Task validés, et un id_counter au niveau du module qui est difficile à réinitialiser ou à tester.

Appliquer les améliorations

Demande à Bob d'implémenter les suggestions que tu souhaites conserver :

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.

Révise les modifications proposées et approuve pour les appliquer. Demande à Bob de reconstruire l'image et de redémarrer le conteneur, puis répète les étapes de validation. Confirme que GET /tasks/{task_id} retourne 200 avec la tâche pour un ID valide et 404 pour un ID inconnu, et que les endpoints existants se comportent toujours comme avant.

Générer des tests unitaires

Démarre une nouvelle fenêtre de contexte avec Nouvelle tâche, puis demande à Bob :

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 ajoute les dépendances de test pytest et httpx, construit une image qui les inclut, exécute la suite dans un conteneur et rapporte les résultats. Exécuter les tests dans un conteneur signifie que tu n'as pas besoin d'un environnement Python local. Révise et affine les tests générés.

La révision et la maintenance des tests générés restent de ta responsabilité.

Générer de la documentation technique

Demande à Bob :

Generate technical documentation for this To-Do API.

Bob peut générer une vue d'ensemble de l'application, une description de l'architecture, des résumés des endpoints, des exemples de requêtes et de réponses, et des instructions d'utilisation. Cette documentation complète la documentation API que FastAPI génère automatiquement.