Prompts · Programación
33 prompts para programar con IA
Prompts para entender código, encontrar errores, refactorizar, escribir tests, revisar arquitectura y documentar. Listos para copiar y adaptar.
Pedirle código a una IA es fácil. Conseguir código que funcione, que entiendas y que puedas mantener dentro de seis meses es otra cosa. La diferencia casi siempre está en el prompt: cuánto contexto das, qué restricciones impones y si pides el razonamiento antes que la solución.
Estos 30 prompts están agrupados por la tarea real que estás haciendo. Sustituye lo que aparece entre corchetes y pega siempre el código y el error completos: recortarlos es el error más caro.
Qué vas a encontrar
Entender código ajeno
1. Explicación línea por línea
Explícame este código línea por línea. Después resume qué hace, qué entradas espera, qué devuelve y qué errores podrían aparecer. No lo modifiques todavía:
[CÓDIGO]
2. Mapa de un proyecto desconocido
Acabo de entrar en un proyecto que no conozco. Con esta estructura de archivos y estos ficheros principales, explícame: cuál es el punto de entrada, cómo fluyen los datos, qué hace cada módulo y por dónde debería empezar a leer para entenderlo. Señala lo que no puedas deducir del material que te doy:
[ESTRUCTURA]
[ARCHIVOS CLAVE]
3. Traducir código a lenguaje natural
Convierte esta función en una descripción en español que pueda entender alguien que no programa. Explica qué problema resuelve y en qué casos se usaría, sin usar jerga técnica:
[CÓDIGO]
4. Entender una expresión regular
Descompón esta expresión regular parte por parte y explica qué hace cada fragmento. Después dame tres ejemplos de cadenas que coincidan y tres que no, y señala los casos límite en los que podría fallar:
[REGEX]
Encontrar y arreglar errores
5. Diagnóstico antes que solución
Analiza este código y este error. Primero formula las causas posibles, después identifica cuál es la más probable y finalmente propón el cambio mínimo para solucionarlo. No reescribas todo el proyecto:
[ERROR]
[CÓDIGO]
6. Bug que no da error
Este código se ejecuta sin lanzar ningún error, pero el resultado no es el esperado. Esperaba [COMPORTAMIENTO ESPERADO] y obtengo [COMPORTAMIENTO REAL]. Razona qué parte del flujo puede estar produciendo esa diferencia antes de proponer cambios:
[CÓDIGO]
7. Depuración guiada
No consigo reproducir este fallo de forma fiable. En lugar de darme una solución, dime qué instrucciones de log debería añadir y en qué puntos exactos, qué valores debería observar y cómo interpretar cada resultado posible:
[CÓDIGO]
[SÍNTOMA]
8. Error de dependencias
Tengo este error al instalar o ejecutar dependencias. Explica qué significa exactamente el mensaje, qué lo provoca normalmente y dame las soluciones ordenadas de menos a más invasiva. Advierte de cuáles pueden romper otras partes del entorno:
[MENSAJE DE ERROR]
[GESTOR Y VERSIÓN]
9. Análisis de traza de error
Lee esta traza de error completa. Identifica la línea donde se origina realmente el problema (no donde se manifiesta), explica la cadena de llamadas que lleva hasta ahí y dime qué información me falta para confirmarlo:
[STACK TRACE]
10. Bug de concurrencia
Sospecho que este código tiene un problema de concurrencia: falla de forma intermitente y sin patrón claro. Identifica los recursos compartidos, los puntos donde podría haber condiciones de carrera y propón la protección más sencilla que resuelva el problema sin degradar el rendimiento:
[CÓDIGO]
Refactorizar y mejorar
11. Refactor conservador
Refactoriza este código para mejorar legibilidad y mantenimiento sin cambiar su comportamiento. Explica cada cambio y señala cualquier riesgo de regresión:
[CÓDIGO]
12. Reducir complejidad
Esta función es demasiado larga y difícil de seguir. Divídela en funciones más pequeñas con nombres descriptivos, sin alterar el comportamiento externo. Muéstrame el antes y el después y explica el criterio que has usado para separar cada parte:
[CÓDIGO]
13. Eliminar duplicación
Estos fragmentos de código hacen cosas parecidas. Identifica qué comparten realmente y qué es distinto, y dime si merece la pena unificarlos o si la duplicación está justificada. Si propones unificar, muéstrame la abstracción resultante:
[FRAGMENTO 1]
[FRAGMENTO 2]
14. Nombres mejores
Revisa los nombres de variables, funciones y clases de este código. Señala los que sean ambiguos, engañosos o demasiado genéricos y propón alternativas. Explica brevemente por qué cada nombre nuevo es mejor:
[CÓDIGO]
15. Modernizar código antiguo
Este código usa patrones antiguos de [LENGUAJE]. Actualízalo a las prácticas actuales de la versión [VERSIÓN], manteniendo exactamente el mismo comportamiento. Para cada cambio indica qué característica moderna estás usando y desde qué versión está disponible:
[CÓDIGO]
16. Simplificar condicionales
Esta lógica condicional se ha vuelto difícil de seguir. Reescríbela para que sea más legible usando cláusulas de guarda, early returns o tablas de decisión según convenga. Demuéstrame que la lógica resultante es equivalente caso por caso:
[CÓDIGO]
Tests y calidad
17. Generar tests unitarios
Escribe tests unitarios para esta función usando [FRAMEWORK]. Cubre el caso normal, los casos límite y los casos de error. Para cada test explica qué comportamiento concreto está verificando. No modifiques la función:
[CÓDIGO]
18. Casos límite que se me escapan
Antes de escribir tests, dime qué casos límite debería considerar para esta función: valores vacíos, nulos, negativos, muy grandes, codificaciones raras, concurrencia o cualquier otro que se te ocurra. Ordénalos por probabilidad de causar un fallo real:
[CÓDIGO]
19. Revisión de código
Actúa como revisor de código exigente pero constructivo. Revisa este cambio buscando errores de lógica, problemas de seguridad, fugas de recursos, casos no contemplados y decisiones difíciles de mantener. Clasifica cada comentario como bloqueante, importante o sugerencia:
[DIFF O CÓDIGO]
20. Auditoría de seguridad básica
Revisa este código buscando vulnerabilidades: inyección, validación de entrada insuficiente, secretos en el código, permisos excesivos, deserialización insegura o manejo incorrecto de errores. Para cada hallazgo indica la gravedad, cómo se explotaría y cómo corregirlo:
[CÓDIGO]
21. Detectar deuda técnica
Revisa este módulo e identifica la deuda técnica acumulada. Para cada problema indica qué coste tiene hoy, qué coste tendrá si no se toca en un año y cuánto trabajo aproximado supondría arreglarlo. Ordena por relación entre impacto y esfuerzo:
[CÓDIGO]
Diseño y arquitectura
22. Revisión de arquitectura
Actúa como arquitecto de software. Analiza esta solución, identifica cuellos de botella, problemas de seguridad, deuda técnica y decisiones difíciles de mantener. Propón alternativas y explica sus ventajas y costes:
[DESCRIPCIÓN O CÓDIGO]
23. Comparar dos enfoques
Estoy dudando entre estos dos enfoques para resolver [PROBLEMA]: [OPCIÓN A] y [OPCIÓN B]. Compara ambos en complejidad, rendimiento, facilidad de prueba, coste de mantenimiento y facilidad de revertir la decisión. Dame una recomendación razonada y di explícitamente en qué condiciones cambiaría.
24. Diseñar una API
Diseña la API para [FUNCIONALIDAD]. Define los endpoints o funciones, los parámetros, los formatos de respuesta, los códigos de error y el comportamiento ante entradas inválidas. Justifica cada decisión y señala qué sería difícil de cambiar más adelante.
25. Modelo de datos
Necesito modelar [DOMINIO]. Propón un esquema de datos con entidades, relaciones, claves e índices. Explica qué consultas quedan baratas y cuáles caras con ese diseño, y qué problemas aparecerían si el volumen creciera cien veces.
26. Plan de migración
Quiero migrar de [TECNOLOGÍA ACTUAL] a [TECNOLOGÍA NUEVA]. Propón un plan por fases que permita seguir funcionando durante la migración. Para cada fase indica qué se mueve, cómo se verifica, cómo se revierte si falla y qué riesgos concretos tiene.
Rendimiento
27. Encontrar el cuello de botella
Este código es más lento de lo que debería. Antes de optimizar nada, dime qué mediría yo primero y con qué herramienta, y cuáles son las tres hipótesis más probables sobre dónde se va el tiempo. No optimices a ciegas:
[CÓDIGO]
28. Optimizar con criterio
Optimiza este código. Para cada cambio indica qué mejora esperas, qué legibilidad sacrificas y cómo podría medir si realmente ha servido. Si alguna optimización no merece la pena, dilo:
[CÓDIGO]
29. Consulta lenta
Esta consulta tarda demasiado. Explica cómo se está ejecutando probablemente, qué índices faltarían y cómo reescribirla. Indica qué parte de tu análisis es segura y qué parte necesitaría confirmarse con el plan de ejecución real:
[CONSULTA]
[ESQUEMA]
30. Complejidad algorítmica
Analiza la complejidad temporal y espacial de este código, explicando el razonamiento paso a paso. Después dime si existe un enfoque de menor complejidad y qué haría falta cambiar para lograrlo:
[CÓDIGO]
Documentar y comunicar
31. Documentar una función
Escribe la documentación de esta función siguiendo la convención de [LENGUAJE/ESTILO]. Incluye propósito, parámetros, valor devuelto, excepciones y un ejemplo de uso realista. No describas lo obvio línea por línea:
[CÓDIGO]
32. README de un proyecto
Escribe el README de este proyecto. Incluye qué problema resuelve, requisitos, instalación paso a paso, uso básico con ejemplos, configuración y cómo ejecutar los tests. Escribe para alguien que llega por primera vez y no conoce el contexto:
[DESCRIPCIÓN DEL PROYECTO]
33. Explicar un cambio al equipo
Convierte este cambio técnico en una explicación para el resto del equipo. Di qué cambia, por qué era necesario, a quién afecta, qué hay que hacer para adaptarse y qué pasa si no se hace nada. Evita la jerga innecesaria:
[DIFF O DESCRIPCIÓN]
Tres reglas que cambian el resultado:
1. Pide diagnóstico antes que solución. «Dime las causas posibles y cuál es la más probable» produce mejores arreglos que «arréglalo».
2. Limita el alcance. Si no dices «cambio mínimo», recibirás el archivo entero reescrito.
3. Verifica siempre. Una IA puede inventarse funciones, parámetros y librerías que no existen. Ejecuta el código y lee los tests antes de confiar.
1. Pide diagnóstico antes que solución. «Dime las causas posibles y cuál es la más probable» produce mejores arreglos que «arréglalo».
2. Limita el alcance. Si no dices «cambio mínimo», recibirás el archivo entero reescrito.
3. Verifica siempre. Una IA puede inventarse funciones, parámetros y librerías que no existen. Ejecuta el código y lee los tests antes de confiar.