Programación en pareja con IA con IBM Bob

Lanza IBM Bob

Lanza el IDE IBM Bob.

Abre la interfaz de chat de Bob

Si la interfaz de chat de Bob no está visible, ábrela seleccionando el icono de Bob junto a la barra de navegación. También puedes pulsar Option + Command + B en Mac, o Ctrl + Alt + B en Windows y Linux.

Abre una carpeta de proyecto vacía

Crea una carpeta vacía llamada todo-api, luego ábrela en Bob con Archivo > Abrir carpeta. Si Bob te pregunta si confías en los autores de los archivos de la carpeta, selecciona Sí, confío en los autores.

Bob escribe la aplicación generada en esta carpeta. No necesitas un repositorio existente para este tutorial.

Desactiva la aprobación automática

Abre Permisos y confirma que la aprobación automática está desactivada. Con la aprobación automática desactivada, Bob te pide permiso antes de leer archivos, editar archivos o ejecutar comandos. Mantienes el control de cada cambio en este tutorial.

Cambia al modo Plan

Abre el menú desplegable de modos en la parte inferior de la barra lateral de Bob y selecciona Plan.

Los Modos aplican el principio de mínimo privilegio. En el modo Plan, Bob lee tu código y escribe un plan en Markdown. Bob no ejecuta comandos ni realiza cambios de implementación. Tú revisas el enfoque antes de que Bob escriba código de la aplicación.

Define los requisitos de la aplicación

En la interfaz de chat de Bob, introduce el siguiente 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.

Para construir el plan, Bob ejecuta su skill de planificación. Cuando se te solicite, selecciona Approve skill tools for task y Approve subagent tools for task para que Bob pueda investigar el espacio de trabajo y redactar el plan.

Refina el plan

Puedes cambiar el plan antes de que Bob escriba ningún código. En la interfaz de chat de Bob, introduce un prompt de seguimiento:

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

Bob revisa el plan para incluir la validación de entrada adicional. Revisa el plan actualizado.

Revisa el plan

Bob presenta un plan ordenado y puede guardarlo como un archivo Markdown en el proyecto. Revísalo antes de continuar:

• Alcance: el plan cubre cada endpoint y la regla de validación que añadiste, y nada que no hayas pedido.
• Archivos nombrados: cada paso nombra el archivo que crea o modifica.
• Lenguaje impreciso: frases como "gestionar los errores adecuadamente" ocultan suposiciones. Pide a Bob que las haga específicas.

Sigues siendo responsable de estas decisiones de diseño. Bob no implementa nada hasta que cambies al modo Agent en Genera y revisa la aplicación.

Inicia una nueva ventana de contexto

Selecciona Nueva tarea en el cuadro de chat o + en la parte superior del panel de chat para iniciar una nueva ventana de contexto. Consulta Crear una nueva ventana de contexto para más información. Bob guardó el plan en la carpeta plans, por lo que ya no necesitas la conversación de planificación en el contexto. Un contexto limpio mantiene la implementación enfocada en el plan aprobado.

Cambia al modo Agent y ejecuta el plan

Abre el menú desplegable de modos en la parte inferior de la barra lateral de Bob y selecciona Agent. Luego dile a Bob que implemente el plan:

Implement the plan in the plans folder.
@plans/

El modo Agent permite a Bob escribir archivos y ejecutar comandos. Bob pide aprobación antes de cada cambio porque desactivaste la aprobación automática. Aprueba los pasos mientras Bob trabaja en el plan.

Revisa la aplicación generada

Cuando la implementación esté completa, revisa el código generado. Dado que la salida de Bob es probabilística, tu estilo de código y nombres internos pueden diferir de los ejemplos mostrados aquí. La aplicación consta de las siguientes partes.

Modelos de datos. Bob genera dos modelos Pydantic: uno para el cuerpo de la solicitud al crear una tarea y otro para una tarea almacenada. El modelo de creación impone la regla de longitud que añadiste durante la planificación:

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


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

Las rutas de los endpoints y los códigos de estado coinciden con los requisitos que le diste a Bob, pero los nombres de las clases de modelos y la estructura de archivos pueden variar. Este tutorial asume los modelos Task y TaskCreate. Ajusta los prompts que siguen si Bob eligió nombres diferentes.

Almacén de datos en memoria. Bob almacena las tareas en una lista de Python vacía y asigna a cada nueva tarea un id incremental:

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

Operaciones de la API. La aplicación proporciona los siguientes endpoints:

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

POST /tasks toma solo task_name en el cuerpo de la solicitud y devuelve 201 con la tarea creada. DELETE /tasks/{task_id} devuelve 204 en caso de éxito y 404 cuando ninguna tarea tiene ese task_id.

Dependencias. Bob genera un archivo requirements.txt que lista FastAPI, Uvicorn y Pydantic.

Contenedor. Bob genera un Dockerfile que instala las dependencias y ejecuta la API en el puerto 8000 con Uvicorn.

El contrato HTTP sigue el prompt de requisitos, incluidos los métodos, rutas y códigos de estado. Los siguientes pasos de validación se aplican tal cual están escritos.

Abre el archivo de la aplicación

Abre el archivo main.py que Bob generó y coloca el cursor en una línea vacía al final del archivo, después del último manejador de rutas.

Activa el modo de codificación literaria

Pulsa Command + I en Mac, o Ctrl + I en Windows y Linux. También puedes seleccionar el icono de varita mágica en la barra de herramientas del editor.

Escribe la instrucción

Introduce la siguiente instrucción en la línea vacía. Aparece resaltada en un color diferente al del resto del código.

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 el nombre del parámetro, el modelo de solicitud y el manejo de errores a partir del código circundante, por lo que solo especificas el método y la ruta.

Genera y acepta el código

Selecciona Generar, o pulsa Command + Enter en Mac, o Ctrl + Enter en Windows y Linux. Bob reemplaza tu instrucción con una implementación y muestra un diff en línea.

Revisa el diff, luego selecciona Aceptar todo para aplicar el cambio. Pulsa Command + I en Mac, o Ctrl + I en Windows y Linux de nuevo para salir del modo de codificación literaria.

Pide a Bob que explique el código

Inicia una nueva ventana de contexto con Nueva tarea, luego selecciona Ask en el menú desplegable de modos. El modo Ask responde preguntas y analiza código sin editar archivos. Úsalo cuando quieras una explicación sin cambios.

Comprender el código generado es una parte importante de la programación en pareja con IA. Pregúntale a Bob:

Explain the generated To-Do API.

Bob puede explicar la arquitectura de la aplicación, el flujo de datos, los componentes de FastAPI, los modelos Pydantic, el comportamiento de los endpoints y las decisiones de diseño. Usa la explicación para confirmar que el código hace lo que esperas antes de cambiarlo o ampliarlo.

Ejecuta la aplicación

Vuelve a cambiar al modo Agent para que Bob pueda ejecutar comandos. Pide a Bob que construya y ejecute la API en un contenedor:

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

Bob ejecuta los comandos de construcción e inicio e informa cuando el contenedor está en ejecución.

Abre http://localhost:8000/docs en tu navegador.

FastAPI sirve una interfaz Swagger UI interactiva en /docs. Úsala para explorar cada endpoint, inspeccionar los esquemas de solicitud y respuesta, y ejecutar llamadas a la API desde el navegador.

Valida la API

Usa la Swagger UI en /docs para ejercitar cada operación. Para cada endpoint:

1. Expande su fila y selecciona Try it out.
2. Introduce los parámetros de ruta o el cuerpo de la solicitud necesarios.
3. Selecciona Execute.
4. Comprueba el código y el cuerpo de la Server response.

Añadir una tarea

1. Expande POST /tasks y selecciona Try it out.

2. Reemplaza el cuerpo de la solicitud con:

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

3. Selecciona Execute. Confirma que el código de respuesta es 201 y que el cuerpo de la respuesta muestra la tarea creada con un id asignado.

Recuperar tareas

1. Expande GET /tasks y selecciona Try it out.
2. Selecciona Execute. Confirma que el código de respuesta es 200 y que el cuerpo de la respuesta lista la tarea My first API item! con el id asignado cuando la añadiste.

Actualizar una tarea

1. Expande PUT /tasks/{task_id} y selecciona Try it out.

2. Introduce el task_id de la tarea que creaste.

3. Reemplaza el cuerpo de la solicitud con:

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

4. Selecciona Execute. Confirma que el código de respuesta es 200 y que la tarea devuelta muestra el task_name actualizado.

5. Cambia task_id a un valor que no exista y selecciona Execute de nuevo. Confirma que el código de respuesta es 404.

Eliminar una tarea

1. Expande DELETE /tasks/{task_id} y selecciona Try it out.
2. Introduce el task_id de la tarea que creaste y selecciona Execute. Confirma que el código de respuesta es 204.
3. Expande GET /tasks, selecciona Execute y confirma que la tarea ya no aparece en la respuesta.
4. Expande DELETE /tasks/{task_id} de nuevo, introduce el mismo task_id y selecciona Execute. Confirma que el código de respuesta es 404.

La implementación cumple los requisitos originales, incluido el endpoint de actualización que añadiste con la codificación literaria.

Pide a Bob sugerencias de mejora

Inicia una nueva ventana de contexto con Nueva tarea, luego introduce:

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

Bob identifica carencias como la falta de un endpoint para recuperar una sola tarea, un almacén en memoria que guarda diccionarios simples en lugar de modelos Task validados, y un id_counter a nivel de módulo que es difícil de reiniciar o probar.

Aplica las mejoras

Pide a Bob que implemente las sugerencias que quieres conservar:

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.

Revisa los cambios propuestos y aprueba para aplicarlos. Pide a Bob que reconstruya la imagen y reinicie el contenedor, luego repite los pasos de validación. Confirma que GET /tasks/{task_id} devuelve 200 con la tarea para un ID válido y 404 para un ID desconocido, y que los endpoints existentes siguen comportándose como antes.

Genera pruebas unitarias

Inicia una nueva ventana de contexto con Nueva tarea, luego pregúntale 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 añade las dependencias de prueba pytest e httpx, construye una imagen que las incluye, ejecuta el conjunto de pruebas en un contenedor e informa los resultados. Ejecutar las pruebas en un contenedor significa que no necesitas un entorno Python local. Revisa y refina las pruebas generadas.

La revisión y el mantenimiento de las pruebas generadas siguen siendo tu responsabilidad.

Genera documentación técnica

Pregúntale a Bob:

Generate technical documentation for this To-Do API.

Bob puede generar una descripción general de la aplicación, la descripción de la arquitectura, resúmenes de los endpoints, ejemplos de solicitudes y respuestas, e instrucciones de uso. Esta documentación complementa la documentación de la API que FastAPI genera automáticamente.