Para obtener una explicación útil de un código con IA, di cuánto sabes ya, pide la explicación línea por línea y pide un seguimiento: una tabla con los valores que tiene cada variable mientras se ejecuta el código. Un simple "explica este código" recibe un resumen escrito para un lector medio imaginario, que suele quedarte o demasiado básico o demasiado rápido.
Línea por línea, con un seguimiento de valores
Las dos pestañas preguntan por la misma función corta. Compara lo que te permite comprobar cada respuesta.
def running_max(nums):
result = []
best = None
for n in nums:
if best is None or n > best:
best = n
result.append(best)
return result
print(running_max([3, 1, 4, 1, 5]))
Esta función calcula el máximo acumulado de una lista. Recorre los números, guarda en best el mayor valor visto hasta el momento y añade ese valor a result en cada paso. La comprobación best is None se ocupa del primer elemento. La llamada imprime [3, 3, 4, 4, 5].
La función se ejecuta en tiempo O(n), porque visita cada elemento una vez.
La primera respuesta es correcta, y solo ayuda si ya sabes qué es un máximo acumulado. Además añade una nota sobre complejidad temporal que nadie pidió, el tipo de extra que recibes cuando el modelo no sabe quién lee. La segunda respuesta ata cada frase a una línea que puedes señalar, y la tabla hace concreto lo que el resumen solo menciona de pasada: result.append(best) se ejecuta en cada vuelta, incluidas las vueltas en las que best no cambia. Por eso el 3 aparece dos veces, y lo ves en la fila 2 en lugar de deducirlo de "en cada paso".
Una tabla de seguimiento también sirve para comprobar la propia explicación. Puedes verificar cada fila ejecutando el código con un print(n, best, result) dentro del bucle. Si una fila no coincide con la salida real, la explicación está mal en algún punto, y ahora sabes dónde.
Que te lo explique a tu nivel
La línea más útil de un prompt de explicación es lo que ya sabes. Le dice al modelo qué líneas saltarse y en cuáles ir despacio. Una frase de rol también puede ayudar ("Eres un tutor para personas en su primer mes programando"), pero funciona por el mismo mecanismo: le dice al modelo quién es el lector. Prompting de rol explica qué cambia un rol y qué no.
Este bloque es una versión reutilizable. Cambia el nivel, la parte confusa o el código, y la explicación cambia con ellos.
text = "the cat and the hat"
counts = {}
for word in text.split():
counts[word] = counts.get(word, 0) + 1
top = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)[:2]
print(top)El bucle cuenta cada palabra: counts termina como {'the': 2, 'cat': 1, 'and': 1, 'hat': 1}.
Ahora las dos últimas líneas, de dentro hacia fuera:
counts.items()da los pares('the', 2),('cat', 1),('and', 1),('hat', 1).lambda kv: kv[1]es una función diminuta sin nombre. Recibe un par y devuelve su segundo elemento, el recuento. Para('the', 2)devuelve2.sorted(..., key=...)ordena los pares según lo que devuelve esa función, así que ordena por recuento.reverse=Truepone primero el mayor. Las palabras con el mismo recuento conservan su orden original.[:2]se queda con los dos primeros pares.
Así que top es [('the', 2), ('cat', 1)], y eso es lo que se imprime.
"Las palabras con el mismo recuento conservan su orden original" es el detalle que una explicación rápida omite, y es el motivo por el que cat se queda el segundo puesto y no and ni hat. El sorted de Python es estable, y reverse=True mantiene esa estabilidad. No se te ocurriría preguntar por ello, y pedir "el valor que produce cada pieza con esta entrada" es lo que lo sacó a la luz.
Pregunta por una parte, no por todo el archivo
Pegar un archivo de 500 líneas y preguntar "¿qué hace esto?" te da un recorrido por la estructura del archivo. Cuando estás atascado en una función, pega esa función y las líneas que la llaman, y pregunta por ella directamente: "¿Por qué esta función sale antes de tiempo cuando la lista está vacía?" o "¿Qué hace yield en la línea 12 y qué cambiaría si fuera return?". Una pregunta concreta recibe una respuesta sobre tu código; una amplia recibe una respuesta sobre código parecido al tuyo.
Para un código grande y desconocido, dale la vuelta: pide primero un mapa ("enumera los módulos principales y de qué se encarga cada uno, en una línea cada uno") y luego pregunta por el módulo que necesitas. Es una pequeña cadena de prompts, y cada paso mantiene la respuesta del modelo lo bastante corta para poder revisarla.
Que te lo explique a través de un lenguaje que conoces
El código en un lenguaje desconocido se lee mejor cuando la explicación se apoya en uno que conoces. Dilo en el prompt: "Sé Python. Explícame esta función de Go y señala cada lugar donde se comporta distinto de lo que esperaría un programador de Python". Las diferencias son donde viven los malentendidos: la división entera, los valores cero en lugar de None, un slice que comparte memoria con el array del que salió. Una explicación simple del código de Go describiría bien esas líneas y nunca te diría que tu intuición sobre ellas es errónea.
Comprueba que lo entendiste
Una explicación que lees y con la que estás de acuerdo puede dejarte igualmente sin saber escribir el código tú mismo. Dos prompts cierran esa brecha:
- Predice primero. Antes de ejecutar el código o pedir una explicación, anota qué crees que imprime. Luego pídele al modelo que explique solo las líneas en las que tu predicción falló.
- Explícalo con tus palabras. Escribe tu propia explicación y pídele al modelo que señale lo que esté mal o falte, sin reescribirla.
def running_max(nums):
result = []
best = None
for n in nums:
if best is None or n > best:
best = n
result.append(best)
return result
Hazme 3 preguntas que comprueben si de verdad lo entiendo, una a la vez. Incluye una pregunta en la que tenga que predecir la salida para una entrada nueva. Espera mi respuesta antes de hacer la siguiente pregunta, y dime si mi respuesta es correcta y por qué.Pregunta 1 de 3: ¿qué devuelve running_max([2, 7, 5, 9])? Resuélvelo antes de ejecutarlo.
El mismo enfoque funciona cuando un programa se comporta mal, pero entonces quieres la causa, no una lección: consulta prompts para depurar. Cuando el código que tienes delante lo escribió una IA, una explicación línea por línea es una forma rápida de revisarlo antes de quedártelo; prompts para escribir código enumera las demás comprobaciones que conviene hacer.
Preguntas frecuentes
¿Cómo le pido a ChatGPT o Claude que explique un código?
Pega el código y di tres cosas: qué sabes ya, qué parte te confunde y qué forma quieres que tenga la explicación. "Explica cada línea en una frase y luego muestra una tabla con las variables después de cada vuelta del bucle" da una respuesta mucho más útil que "explica este código".
¿Qué es una tabla de seguimiento?
Una tabla de seguimiento (lo que en clase se suele llamar prueba de escritorio) sigue un programa mientras se ejecuta: una fila por paso (a menudo una vuelta del bucle), una columna por variable y el valor de cada variable en ese punto. Pedirla convierte una descripción abstracta en valores concretos que puedes contrastar con el código. Es un registro escrito de lo que te muestra un depurador al avanzar por un programa.
¿La IA puede explicarme código en un lenguaje que no conozco?
Sí, y es una de las cosas más útiles que puedes pedirle. Nombra un lenguaje que sí conozcas y pídele al modelo que compare: "Sé Python; explícame este código de Rust y señala dónde se comporta distinto de Python". Comprueba lo que diga sobre el comportamiento del lenguaje ejecutando ejemplos pequeños, porque las explicaciones pueden equivocarse con total seguridad en los detalles.
¿Usar IA para que me explique código es malo para aprender?
Depende de lo que hagas después. Leer una explicación y pasar a otra cosa enseña poco. Predecir la salida antes de ejecutar el código, pedirle al modelo que te haga preguntas o explicarle el código con tus palabras y preguntar qué te salió mal te obligan a pensar, y ahí es donde se aprende.
