Pair programming con IA con IBM Bob

Avvia IBM Bob

Avvia l'IDE IBM Bob.

Apri l'interfaccia chat di Bob

Se l'interfaccia chat di Bob non è visibile, aprila selezionando l'icona Bob accanto alla barra di navigazione. Puoi anche premere Option + Command + B su Mac, oppure Ctrl + Alt + B su Windows e Linux.

Apri una cartella di progetto vuota

Crea una cartella vuota chiamata todo-api, poi aprila in Bob con File > Apri cartella. Se Bob ti chiede se ti fidi degli autori dei file nella cartella, seleziona Sì, mi fido degli autori.

Bob scrive l'applicazione generata in questa cartella. Non hai bisogno di un repository esistente per questo tutorial.

Disabilita l'approvazione automatica

Apri Permessi e conferma che l'approvazione automatica sia disattivata. Con l'approvazione automatica disattivata, Bob ti chiede il permesso prima di leggere file, modificare file o eseguire comandi. In questo tutorial resti in controllo di ogni modifica.

Passa alla modalità Plan

Apri il menu a tendina della modalità in fondo alla sidebar di Bob e seleziona Plan.

Le modalità applicano il principio del privilegio minimo. In modalità Plan, Bob legge il tuo codice e scrive un piano in Markdown. Bob non esegue comandi né apporta modifiche all'implementazione. Revisioni l'approccio prima che Bob scriva il codice dell'applicazione.

Definisci i requisiti dell'applicazione

Nell'interfaccia chat di Bob, inserisci il seguente prompt:

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.

Per costruire il piano, Bob esegue la sua skill di pianificazione. Quando richiesto, seleziona Approva strumenti skill per il task e Approva strumenti subagent per il task così Bob può esaminare il workspace e redigere il piano.

Affina il piano

Puoi modificare il piano prima che Bob scriva qualsiasi codice. Nell'interfaccia chat di Bob, inserisci un prompt di follow-up:

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

Bob rivede il piano per includere la validazione aggiuntiva dell'input. Revisiona il piano aggiornato.

Revisiona il piano

Bob presenta un piano ordinato e potrebbe salvarlo come file Markdown nel progetto. Revisionalo prima di continuare:

• Ambito: il piano copre ogni endpoint e la regola di validazione che hai aggiunto, e niente che non hai richiesto.
• File nominati: ogni passaggio indica il file che crea o modifica.
• Linguaggio vago: frasi come "gestisci gli errori in modo appropriato" nascondono assunzioni. Chiedi a Bob di renderle specifiche.

Sei tu il responsabile di queste decisioni di progettazione. Bob non implementa nulla finché non passi alla modalità Agent in Genera e revisiona l'applicazione.

Avvia una nuova context window

Seleziona Nuovo task nella casella della chat oppure + in cima al pannello della chat per avviare una nuova context window. Consulta Crea una nuova context window per ulteriori informazioni. Bob ha salvato il piano nella cartella plans, quindi non hai più bisogno della conversazione di pianificazione nel contesto. Un contesto pulito mantiene l'implementazione focalizzata sul piano approvato.

Passa alla modalità Agent ed esegui il piano

Apri il menu a tendina della modalità in fondo alla sidebar di Bob e seleziona Agent. Poi di' a Bob di implementare il piano:

Implement the plan in the plans folder.
@plans/

La modalità Agent permette a Bob di scrivere file ed eseguire comandi. Bob chiede l'approvazione prima di ogni modifica perché hai disabilitato l'approvazione automatica. Approva i passaggi mentre Bob lavora attraverso il piano.

Revisiona l'applicazione generata

Quando l'implementazione è completa, revisiona il codice generato. Poiché l'output di Bob è probabilistico, lo stile del codice e i nomi interni potrebbero differire dagli esempi mostrati qui. L'applicazione è composta dalle seguenti parti.

Modelli dati. Bob genera due modelli Pydantic: uno per il corpo della richiesta durante la creazione di un task e uno per un task salvato. Il modello di creazione applica la regola di lunghezza aggiunta durante la pianificazione:

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


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

I percorsi degli endpoint e i codici di stato corrispondono ai requisiti forniti a Bob, ma i nomi delle classi dei modelli e il layout dei file possono variare. Questo tutorial assume i modelli Task e TaskCreate. Adatta i prompt che seguono se Bob ha scelto nomi diversi.

Data store in memoria. Bob salva i task in una lista Python vuota e assegna a ogni nuovo task un id incrementale:

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

Operazioni API. L'applicazione fornisce i seguenti endpoint:

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

POST /tasks prende solo task_name nel corpo della richiesta e restituisce 201 con il task creato. DELETE /tasks/{task_id} restituisce 204 in caso di successo e 404 quando nessun task ha quel task_id.

Dipendenze. Bob genera un file requirements.txt che elenca FastAPI, Uvicorn e Pydantic.

Container. Bob genera un Dockerfile che installa le dipendenze ed esegue l'API sulla porta 8000 con Uvicorn.

Il contratto HTTP segue il prompt dei requisiti, inclusi metodi, percorsi e codici di stato. I seguenti passaggi di validazione si applicano come scritto.

Apri il file dell'applicazione

Apri il file main.py generato da Bob e posiziona il cursore su una riga vuota alla fine del file, dopo l'ultimo route handler.

Attiva la modalità literate coding

Premi Command + I su Mac, oppure Ctrl + I su Windows e Linux. Puoi anche selezionare l'icona della bacchetta magica nella toolbar dell'editor.

Scrivi l'istruzione

Inserisci la seguente istruzione sulla riga vuota. Appare evidenziata in un colore diverso rispetto al resto del codice.

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 deduce il nome del parametro, il modello della richiesta e la gestione degli errori dal codice circostante, quindi devi specificare solo il metodo e il percorso.

Genera e accetta il codice

Seleziona Genera, oppure premi Command + Enter su Mac, oppure Ctrl + Enter su Windows e Linux. Bob sostituisce la tua istruzione con un'implementazione e mostra un diff inline.

Revisiona il diff, poi seleziona Accetta tutto per applicare la modifica. Premi di nuovo Command + I su Mac, oppure Ctrl + I su Windows e Linux per uscire dalla modalità literate coding.

Chiedi a Bob di spiegare il codice

Avvia una nuova context window con Nuovo task, poi seleziona Ask dal menu a tendina della modalità. La modalità Ask risponde alle domande e analizza il codice senza modificare i file. Usala quando vuoi una spiegazione senza modifiche.

Capire il codice generato è una parte importante del pair programming con IA. Chiedi a Bob:

Explain the generated To-Do API.

Bob può spiegare l'architettura dell'applicazione, il flusso dei dati, i componenti FastAPI, i modelli Pydantic, il comportamento degli endpoint e le decisioni di progettazione. Usa la spiegazione per confermare che il codice fa ciò che ti aspetti prima di modificarlo o estenderlo.

Esegui l'applicazione

Torna alla modalità Agent in modo che Bob possa eseguire comandi. Chiedi a Bob di costruire ed eseguire l'API in un container:

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

Bob esegue i comandi di build e avvio e segnala quando il container è in esecuzione.

Apri http://localhost:8000/docs nel tuo browser.

FastAPI serve un'interfaccia Swagger UI interattiva su /docs. Usala per esplorare ogni endpoint, ispezionare gli schemi di richiesta e risposta, ed eseguire chiamate API dal browser.

Valida l'API

Usa la Swagger UI su /docs per esercitare ogni operazione. Per ogni endpoint:

1. Espandi la sua riga e seleziona Try it out.
2. Inserisci eventuali parametri di percorso o corpo della richiesta.
3. Seleziona Execute.
4. Controlla il codice e il corpo della Server response.

Aggiungi un task

1. Espandi POST /tasks e seleziona Try it out.

2. Sostituisci il corpo della richiesta con:

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

3. Seleziona Execute. Conferma che il codice di risposta sia 201 e che il corpo della risposta mostri il task creato con un id assegnato.

Recupera i task

1. Espandi GET /tasks e seleziona Try it out.
2. Seleziona Execute. Conferma che il codice di risposta sia 200 e che il corpo della risposta elenci il task My first API item! con l'id assegnato quando l'hai aggiunto.

Aggiorna un task

1. Espandi PUT /tasks/{task_id} e seleziona Try it out.

2. Inserisci il task_id del task che hai creato.

3. Sostituisci il corpo della richiesta con:

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

4. Seleziona Execute. Conferma che il codice di risposta sia 200 e che il task restituito mostri il task_name aggiornato.

5. Cambia task_id con un valore che non esiste e seleziona di nuovo Execute. Conferma che il codice di risposta sia 404.

Elimina un task

1. Espandi DELETE /tasks/{task_id} e seleziona Try it out.
2. Inserisci il task_id del task che hai creato e seleziona Execute. Conferma che il codice di risposta sia 204.
3. Espandi GET /tasks, seleziona Execute e conferma che il task non appaia più nella risposta.
4. Espandi di nuovo DELETE /tasks/{task_id}, inserisci lo stesso task_id e seleziona Execute. Conferma che il codice di risposta sia 404.

L'implementazione soddisfa i requisiti originali, incluso l'endpoint di aggiornamento aggiunto con il literate coding.

Chiedi a Bob suggerimenti di miglioramento

Avvia una nuova context window con Nuovo task, poi inserisci:

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

Bob identifica lacune come un endpoint mancante per recuperare un singolo task, un data store in memoria che contiene dizionari plain invece di modelli Task validati e un id_counter a livello di modulo difficile da reimpostare o testare.

Applica i miglioramenti

Chiedi a Bob di implementare i suggerimenti che vuoi mantenere:

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.

Revisiona le modifiche proposte e approva per applicarle. Chiedi a Bob di ricostruire l'immagine e riavviare il container, poi ripeti i passaggi di validazione. Conferma che GET /tasks/{task_id} restituisca 200 con il task per un ID valido e 404 per un ID sconosciuto, e che gli endpoint esistenti si comportino come prima.

Genera unit test

Avvia una nuova context window con Nuovo task, poi chiedi a 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 aggiunge le dipendenze di test pytest e httpx, costruisce un'immagine che le include, esegue la suite in un container e riporta i risultati. Eseguire i test in un container significa che non hai bisogno di un ambiente Python locale. Revisiona e affina i test generati.

La revisione e la manutenzione dei test generati rimangono una tua responsabilità.

Genera documentazione tecnica

Chiedi a Bob:

Generate technical documentation for this To-Do API.

Bob può generare una panoramica dell'applicazione, una descrizione dell'architettura, riepiloghi degli endpoint, esempi di richiesta e risposta e istruzioni d'uso. Questa documentazione integra la documentazione API che FastAPI genera automaticamente.