En esta guía encontrarás prompts para depurar código y generar tests unitarios con IA, además de un método para validar cada propuesta.
Depurar y escribir tests son dos de las tareas donde más se nota la ayuda de un asistente de IA, y también donde más fácil es caer en un uso poco crítico. Un modelo puede leer un mensaje de error, proponer hipótesis y sugerir una corrección en segundos; también puede generar una batería de tests que cubra casos que no habías considerado. Pero puede equivocarse con total seguridad, inventar funciones que no existen o escribir tests que pasan siempre porque no comprueban nada. Además, la clave está en usarlo como un compañero rápido al que hay que verificar, no como un oráculo.

En esta guía tienes prompts listos para depurar y para generar tests unitarios, un método para formular bien el problema, un ejemplo práctico completo y una lista de comprobaciones para validar lo que devuelve el asistente. Los ejemplos usan Python y JavaScript por ser frecuentes, pero el enfoque vale para cualquier lenguaje.
Qué necesitas antes de usar prompts para depurar código
- Un fallo reproducible. Si no puedes reproducirlo, ni tú ni la IA podréis aislarlo. Anota los pasos exactos, los datos de entrada y el comportamiento esperado frente al observado.
- El mensaje de error completo. Incluye la traza (stack trace), no solo la última línea. Las líneas intermedias suelen contener la pista decisiva.
- El código relevante y su contexto. La función que falla, las que la llaman y las dependencias implicadas. No pegues el proyecto entero; selecciona lo imprescindible.
- Versiones y entorno. Lenguaje, framework, librerías y sistema. Muchos errores dependen de versiones concretas.
- Un framework de tests instalado. Por ejemplo, pytest en Python, Jest o Vitest en JavaScript, JUnit en Java. Así podrás ejecutar de inmediato lo que genere el asistente.
- Datos limpios. Quita claves, tokens, datos personales y cualquier información confidencial antes de pegar nada en una herramienta externa. Comprueba la política de tu empresa.
Prompts para depurar código: cómo formular el problema
La calidad de la ayuda depende de cómo describas el problema. Asimismo, una buena descripción contiene cinco elementos:
- Qué esperabas que ocurriera.
- Qué ocurre en realidad.
- Cómo reproducirlo. Pasos y datos mínimos.
- Qué has probado ya. Evita que te sugiera lo que has descartado.
- El código y el error. Completos y pegados en bloques de código.
Si faltan datos, pide al asistente que te pregunte antes de proponer una solución. Mejor dos preguntas que una respuesta equivocada.
Prompt 1: depurar un error con traza
Actúa como ingeniero de software senior con experiencia en [lenguaje/framework]. Tengo este problema: Comportamiento esperado: [descripción] Comportamiento observado: [descripción] Cómo reproducirlo: [pasos y datos de entrada] Entorno: [versión del lenguaje, librerías, sistema operativo] Lo que ya he probado: [lista] Código relevante: [pega aquí el código] Error o traza completa: [pega aquí el error] Quiero que: 1. Expliques en lenguaje claro qué significa el error. 2. Propongas de 2 a 4 hipótesis ordenadas por probabilidad. 3. Para cada hipótesis, indiques cómo comprobarla (log, test, depurador) antes de cambiar código. 4. Solo después, sugieras una corrección mínima. No inventes funciones ni parámetros de librerías; si no estás seguro de que existan, dilo. Si te falta información, pregúntamela primero.
Observa el orden: hipótesis, comprobación y solo después, corrección. Por otro lado, evita que el asistente «adivine» un parche y te obliga a entender la causa.
Análisis de un comportamiento incorrecto sin error (prompt 2)
Esta función debería [comportamiento esperado] pero con la entrada [ejemplo] devuelve [resultado obtenido] en lugar de [resultado esperado]. [pega la función y, si procede, las funciones auxiliares] Haz una ejecución paso a paso con esa entrada, indicando el valor de cada variable relevante en cada línea. Señala el punto donde el comportamiento deja de coincidir con lo esperado y explica por qué. Después propone un test que reproduzca el fallo antes de corregirlo.
Este prompt recupera una técnica clásica, la ejecución manual con valores, que los modelos hacen razonablemente bien en funciones pequeñas. En funciones grandes pierde fiabilidad; compruébalo siempre con el depurador.
Generar tests unitarios (prompt 3)
Escribe tests unitarios con [pytest / Jest / JUnit] para esta función: [pega la función] Contexto: [qué hace y qué reglas de negocio aplica]. Incluye: - Casos normales representativos. - Casos límite (vacíos, nulos, valores extremos, tipos inesperados). - Casos de error con las excepciones esperadas. - Un test por cada regla de negocio que menciones. Usa nombres de tests descriptivos y el patrón preparar / ejecutar / comprobar. No uses mocks salvo para dependencias externas. Antes del código, lista los casos que vas a cubrir y señala qué comportamientos no estás seguro de si son los deseados, para que yo los confirme.
Revisar tests existentes (prompt 4)
Revisa estos tests y la función que prueban: [pega función y tests] Indica: 1. Casos importantes que no están cubiertos. 2. Tests que no comprueban nada útil (aserciones débiles o siempre verdaderas). 3. Dependencias entre tests o datos compartidos que puedan causar fallos intermitentes. 4. Nombres poco claros. Propón mejoras concretas, mostrando solo el código que cambia.
Ejemplo práctico de prompts para depurar código
Supón que tienes en Python una función que calcula el precio final con descuentos acumulables. Además, un cliente protesta porque con un cupón del 10 % y un descuento del 5 % en el carrito el precio no coincide con el esperado: el sistema aplica un 15 % en total, y por política de la tienda los descuentos deben aplicarse de forma sucesiva (primero uno, luego el otro sobre el resultado).
Pegas la función con el prompt 2 y el caso concreto. El asistente hace la ejecución paso a paso y detecta que la función suma los porcentajes en lugar de aplicarlos en cadena. Asimismo, propone un test que reproduce el fallo: con un precio de 100, el resultado esperado es 85,50 y la función devuelve 85. Ejecutas el test, falla como se esperaba y solo entonces aplicas la corrección, que multiplica los factores. Además, el test pasa.
Después usas el prompt 3 para generar una batería de tests. El asistente propone casos de precio cero, descuentos del 100 %, descuentos mayores del 100 % (que deberían rechazarse), lista de descuentos vacía y precios con muchos decimales. Revisando, notas que un test acepta un resultado con diferencias de redondeo sin definir tolerancia, y que otro asume que un descuento negativo sube el precio, algo que no habías especificado. Asimismo, confirmas con el responsable del producto que los descuentos negativos deben lanzar un error y ajustas el test. Resultado: una corrección verificada y una red de seguridad contra regresiones, en menos tiempo del que habría llevado hacerlo todo a mano.
Cómo validar lo que propone el asistente
Estas comprobaciones deberían ser un hábito:
- Ejecuta siempre el código y los tests. No des por buena ninguna sugerencia sin ver el resultado.
- Comprueba que el test falla antes de la corrección. Si un test pasa antes y después, no demuestra nada.
- Verifica que las funciones y librerías existen. Los modelos pueden inventar nombres de métodos o parámetros. Consulta la documentación oficial.
- Revisa las aserciones. Un test sin aserciones relevantes pasa siempre. Desconfía de tests que solo comprueban que «no lanza excepción».
- Lee el diff completo. A veces el asistente cambia más de lo necesario o reformatea código ajeno al problema.
- Prueba casos que el asistente no consideró. Tu conocimiento del dominio es complementario.
- Mide cobertura con criterio. Una cobertura alta con aserciones flojas da una falsa sensación de seguridad.
- Revisa seguridad. Validación de entradas, consultas a bases de datos, gestión de errores y datos sensibles.
Buenas prácticas con tests generados por IA
- Especifica el comportamiento, no la implementación. Los tests deben comprobar qué hace la función, no cómo lo hace, para sobrevivir a refactorizaciones.
- Evita tests frágiles. Dependencias de fechas, orden de ejecución, red o datos aleatorios sin semilla causan fallos intermitentes.
- Pide casos límite explícitamente. Los modelos tienden a cubrir el caso feliz y olvidar los bordes.
- Usa datos de prueba realistas pero ficticios. Nunca pegues datos reales de clientes.
- Mantén los tests legibles. Un test también documenta el comportamiento; que se entienda sin leer la implementación.
- Itera por funciones pequeñas. Pedir tests de un módulo entero de golpe produce resultados más débiles que hacerlo función a función.
Errores frecuentes con prompts para depurar código
- Pegar solo la última línea del error. Pierdes el contexto más útil. Incluye la traza completa.
- Pedir «arréglalo» sin descripción. El asistente adivinará. Describe esperado, obtenido y reproducción.
- Aplicar el parche sin entender la causa. Hoy funciona y mañana reaparece con otra forma. Comprende el porqué.
- Confiar en tests que nunca han fallado. Un test que no puede fallar no protege.
- Aceptar código con dependencias nuevas sin comprobarlas. Verifica que existen, que están mantenidas y que su licencia es compatible.
- Pegar secretos o datos personales. Claves, tokens, datos de usuarios y configuración sensible no deben salir de tu entorno.
- Usar la IA para evitar leer la documentación. Para comportamientos concretos de una librería, la referencia oficial manda.
- Pedir demasiado en una sola conversación. Conversaciones largas degradan la precisión. Divide por problemas y abre una nueva cuando cambie el tema.
Preguntas frecuentes sobre prompts para depurar código
¿La IA puede depurar cualquier error?
No. Ayuda mucho con errores comunes, mensajes claros y funciones pequeñas. Por otro lado, con fallos de concurrencia, problemas de entorno o dependientes de datos que no ve, se limita a formular hipótesis que tienes que comprobar.
¿Es seguro pegar mi código en un asistente?
Depende de la herramienta y de las políticas de tu organización. Revisa la privacidad y retención de datos, quita secretos y datos personales y no uses servicios no autorizados con código confidencial.
¿Qué cobertura de tests debo buscar?
No hay un número mágico. Además, prioriza la lógica de negocio crítica y los casos límite. Una cobertura moderada con buenas aserciones vale más que una cobertura alta con tests superficiales.
¿Los tests generados por IA son fiables?
Son un buen punto de partida, pero requieren revisión: aserciones relevantes, casos límite, independencia entre tests y coherencia con las reglas reales del negocio.
¿Puedo pedirle que escriba tests antes que el código?
Sí. Asimismo, describe el comportamiento deseado y pide los tests primero, como en el desarrollo guiado por tests. Después implementa y comprueba que pasan. Es una práctica muy útil para clarificar requisitos.
¿Qué hago si el asistente propone algo que no funciona?
Pega el nuevo error o resultado, indica qué ha cambiado y pide que revise su hipótesis. Además, si tras dos o tres intentos no avanzas, empieza una conversación limpia con una descripción mejorada o recurre al depurador y a la documentación.
Ejemplo de test útil frente a test débil
Para entender la diferencia entre un test que protege y uno que solo aparenta hacerlo, compara estos dos para la función de descuentos del ejemplo anterior:
# Test débil: pasa aunque la función devuelva cualquier cosa
def test_descuento_no_falla():
resultado = precio_final(100, [0.10, 0.05])
assert resultado is not None
# Test útil: comprueba el valor esperado y documenta la regla
def test_descuentos_se_aplican_en_cadena():
assert precio_final(100, [0.10, 0.05]) == pytest.approx(85.50)El primero se escribe en segundos y da sensación de cobertura, pero no detectaría el fallo original. El segundo comprueba una regla de negocio concreta y habría fallado antes de la corrección. Asimismo, cuando un asistente genere tests, busca activamente aserciones del primer tipo y pídele que las sustituya por comprobaciones de valores concretos.
Flujo recomendado con prompts para depurar código
- Reproduce el fallo y escribe (o pide) un test que lo capture.
- Pide hipótesis, no soluciones, y comprueba cada una con logs o con el depurador.
- Aplica la corrección mínima y ejecuta el test que fallaba.
- Amplía la batería con casos límite relacionados, revisando cada aserción.
- Ejecuta toda la suite y revisa el diff antes de confirmar el cambio en Git, con un mensaje de commit que explique la causa del error y no solo el parche.
Seguir siempre este orden crea un hábito saludable: la IA acelera cada paso, pero el método es tuyo y es lo que garantiza que el error no vuelva.
Más recursos sobre prompts para depurar código
Además, conviene contrastar siempre la información con fuentes fiables, como la documentación oficial de pytest. Por otro lado, si quieres profundizar, puedes leer nuestra guía para documentar código y revisar pull requests.
¿Qué IA es mejor para programadores que quieren depurar código?
Depende de tu entorno. Cualquier asistente con buen soporte de tu lenguaje sirve si le das la traza completa y el contexto. Por otro lado, prueba dos o tres con el mismo problema y compara.
Fuentes oficiales para profundizar
Para profundizar en prompts para depurar código, conviene contrastar con fuentes oficiales y no fiarse solo de lo que genera una IA.
- documentación de GitHub Copilot: Cómo funciona y se configura este asistente de código.
- Claude Code: Página oficial de esta herramienta de programación.
- Cursor: Sitio oficial del editor con IA integrada.
Guías relacionadas
- ¿Puede la IA sustituir a un programador? Análisis para España
- GitHub Copilot, Cursor y Claude Code: cuál elegir
- Cómo usar la IA para programar más rápido: guía para desarrolladores junior
- 50 prompts de ChatGPT para profesionales de cualquier sector
Conclusión sobre los prompts para depurar código
Un asistente de IA puede acelerar la depuración y la creación de tests si le das buen contexto, le pides hipótesis antes de parches y verificas cada resultado ejecutando el código. Tu papel no desaparece: pasa de teclear a formular bien el problema, juzgar propuestas y asegurar la calidad. Además, empieza con una función pequeña, aplica los cuatro prompts, comprueba que los tests fallan cuando deben y guarda tus mejores plantillas para el resto del proyecto.





