Programar con IA y buenas prácticas

Llegamos al último módulo. Tu PROYECTO FINAL ya tiene entorno virtual, control de versiones, repositorio en GitHub y un Dockerfile. Falta la pieza que define a esta era: un flujo de trabajo asistido por IA, hecho con criterio. Aquí aprendes a usar Copilot, Claude Code, Cursor y OpenCode como lo que son —ayudantes potentes pero falibles— y a auditar lo que generan para que tu proyecto siga siendo tuyo y sigues entendiéndolo.

¿Qué es?

La programación asistida por IA consiste en apoyarte en modelos de lenguaje para escribir, explicar, refactorizar y depurar código. No reemplaza saber programar: lo acelera. Los protagonistas hoy:

• GitHub Copilot: autocompletado inteligente dentro del editor; sugiere líneas y bloques mientras escribes.
• Claude Code: agente de terminal de Anthropic que lee tu proyecto, ejecuta comandos y edita archivos siguiendo tus instrucciones.
• Cursor: un editor (fork de VS Code) con la IA integrada en el flujo, con chat sobre tu base de código.
• OpenCode: alternativa de agente de terminal de código abierto, similar en espíritu a Claude Code.

¿Cómo funciona?

Todas estas herramientas leen contexto —tu código, tus errores, tus instrucciones— y producen texto: código, explicaciones o comandos. La calidad de lo que recibes depende directamente de la calidad de lo que les das. Un buen prompt describe el objetivo, las restricciones y el formato esperado.

Los agentes de terminal (Claude Code, OpenCode) van un paso más allá: además de sugerir, actúan. Pueden crear archivos, correr tests y proponer commits. Por eso el control humano —revisar antes de aceptar— deja de ser opcional y pasa a ser obligatorio.

¿Para qué sirve?

• Velocidad: andamiaje, código repetitivo y refactors en una fracción del tiempo.
• Aprendizaje: pides que te expliquen un error o un fragmento, y entiendes el porqué.
• Depuración: pegas el mensaje de error y obtienes hipótesis ordenadas de la causa.
• Documentación: generas borradores de README, docstrings y comentarios que luego revisas.

Construyamos esta pieza del proyecto

Paso 1: una estructura de proyecto que la IA (y tú) entiendan

Una buena estructura ayuda tanto a la persona como al agente a orientarse. Para nuestro proyecto:

mi-entorno-pro/
├── .venv/ # entorno virtual (ignorado por Git)
├── src/ # código fuente
│ └── app.py
├── tests/ # pruebas
│ └── test_app.py
├── requirements.txt # dependencias congeladas
├── .gitignore
├── .dockerignore
├── Dockerfile
└── README.md

Paso 2: leer un error antes de pedir ayuda

Antes de pegarle un error a la IA, léelo tú. Los errores de Python se leen de abajo hacia arriba: la última línea dice el tipo de error y el mensaje; las de arriba, el rastro de cómo se llegó allí (traceback).

Traceback (most recent call last):
 File "src/app.py", line 4, in <module>
 print(reqests.__version__)
 ^^^^^^^
NameError: name 'reqests' is not defined

La última línea lo dice todo: reqests está mal escrito (falta una u). No necesitabas a nadie para esto. Reserva la IA para lo que de verdad no entiendes.

Paso 3: depurar con método (con o sin IA)

El método no cambia porque haya IA:

1. Reproduce el error de forma consistente.
2. Aísla: reduce el código al mínimo que falla.
3. Inspecciona: imprime valores o usa el depurador.

# Depuración rápida con prints
print("DEBUG valor:", repr(valor))

# Depurador interactivo: detiene la ejecución aquí
import pdb; pdb.set_trace()

Cuando recurras a la IA, dale el traceback completo, el fragmento relevante y qué esperabas que pasara. Cuanto mejor el contexto, mejor la hipótesis.

Paso 4: escribir buenos prompts

Un prompt útil es específico y acotado. Compara:

Malo: "arregla mi código"
Bueno: "Esta función debe devolver la suma de los números pares de
 una lista. Con [1,2,3,4] devuelve 4 en vez de 6. Aquí está
 la función y el test que falla. ¿Dónde está el bug?"

Dale el objetivo, el comportamiento esperado, el real y el código mínimo. Pide también que explique el cambio, no solo que lo aplique: así aprendes y puedes auditar.

Paso 5: auditar lo que genera la IA (lo más importante)

Nunca aceptes código a ciegas. Antes de quedártelo, pásalo por esta lista:

• ¿Lo entiendo? Si no puedes explicar línea por línea qué hace, no está listo para tu proyecto.
• ¿Las dependencias son reales? Verifica que las librerías importadas existen y están en requirements.txt. La IA inventa paquetes.
• ¿Maneja los casos límite? Listas vacías, valores nulos, entradas inesperadas.
• ¿Hay riesgos de seguridad? Cuidado con secretos en el código, eval, comandos de shell sin sanear.
• ¿Pasa los tests? Que el cambio no rompa lo que ya funcionaba.

Y aquí es donde se cierra el círculo con todo el curso: Git es tu red de seguridad para usar IA sin miedo. Trabaja siempre en una rama, deja que el agente proponga cambios, revísalos con git diff y comitea solo lo que entiendes.

git switch -c feature/funcion-con-ia
# ...la IA edita el código...
git diff # AUDITA cada línea antes de aceptar
pytest # corre los tests
git add -p # añade por trozos, revisando cada uno
git commit -m "Añade función X (revisada)"

Ejercicios

1. Introduce un bug a propósito en src/app.py (por ejemplo, una variable mal escrita). Ejecuta, lee el traceback de abajo hacia arriba y arréglalo sin IA. Luego escribe el prompt que le habrías dado a un asistente para resolverlo, aplicando la regla del Paso 4.
2. Pide a un asistente (Copilot, Claude Code, Cursor u OpenCode) que añada una función nueva a tu proyecto en una rama. Antes de aceptarla, audítala con la lista del Paso 5, revísala con git diff, corre los tests y solo entonces haz commit. Escribe en dos frases qué cambiarías de lo que generó y por qué.