Mi método para revisar código generado por IA sin poner en riesgo mi web
Resumen rápido: Antes de publicar lo que escribe un asistente, trátalo como el trabajo de un colaborador nuevo. Contrástalo con los requisitos, léelo con sospecha, pasa analizadores de seguridad, audita dependencias, busca secretos y ejecuta pruebas. Solo entonces se publica, y una persona responde por él.
Empecé a revisar código generado por IA de verdad el día que un formulario de contacto, escrito por un asistente, funcionaba perfecto en mi pantalla y, al leerlo con calma, construía la consulta SQL pegando el texto del usuario. Lo vi a tiempo, pero nada fallaba en la demo. El problema solo aparecía leyendo el código, no ejecutándolo. Aprendí que una prueba feliz no demuestra seguridad y que la lectura humana va antes que cualquier herramienta.
Revisar código generado por IA es el proceso de comprobar, con criterio humano y herramientas automáticas, que un fragmento escrito por un asistente cumple los requisitos, no introduce fallos ni vulnerabilidades y puede mantenerse después.
En esta guía te cuento el orden que sigo yo, desde la lectura inicial hasta las pruebas, con las herramientas gratuitas que uso y los casos en los que prefiero no publicar nada.
Por qué el código de una IA necesita una revisión distinta
El código de una IA parece correcto aunque no lo sea: puede mezclar errores de sintaxis, fallos de lógica y vulnerabilidades dentro de un estilo limpio y seguro de sí mismo. Por eso necesita la misma revisión que el de una persona, con atención extra a lo que el asistente desconoce de tu proyecto.
La guía Review AI-generated code, de GitHub Docs, lo plantea sin rodeos: lo que sugiere un asistente puede parecer válido y contener errores sintácticos, problemas semánticos o fallos de seguridad, así que hay que revisarlo y probarlo antes de publicarlo.
Por su parte, OWASP DevSecOps Guideline: AI Governance and Risk recomienda aplicar al código creado por IA la misma revisión de seguridad que al escrito por personas y asignar a un desarrollador la responsabilidad de aceptarlo. Yo lo uso como regla de bolsillo: la IA propone y yo respondo.
La diferencia con revisar el código de un compañero es el contexto. Un compañero conoce tu base de código, tus convenciones y tus riesgos. Un asistente solo conoce lo que pegaste en el prompt y rellena los huecos con suposiciones que suenan razonables.
Mi proceso para revisar código generado por IA, paso a paso
Mi orden de revisión es siempre el mismo: primero contrasto el código con los requisitos, luego lo leo sin ejecutarlo, después paso analizadores automáticos y por último lo pruebo en un entorno aislado. Ir de lo humano a lo automático evita que una herramienta me dé falsa tranquilidad antes de entender qué hace el código.
Contrasta el resultado con los requisitos
Contrastar el código con los requisitos es la forma más rápida de descubrir que el asistente resolvió un problema parecido al mío, pero no el mío. Antes de pedir nada, escribo los requisitos como una lista breve. Cuando el asistente responde, los marco uno a uno sobre el código.
El resultado cambia mucho según cómo pidas el código. Compara estos dos prompts:
- Antes: «Hazme un formulario de contacto.»
- Después: «Crea un formulario de contacto en PHP que valide nombre, email y mensaje en el servidor, use consultas preparadas, limite los envíos repetidos y no muestre errores internos al visitante.»
El segundo prompt me da una lista de requisitos que comprobar. El primero me deja a merced de lo que el asistente decida asumir.
Lee el código antes de ejecutarlo
Leo el código completo, bloque a bloque, y me hago una pregunta: ¿sabría explicar qué hace este código? Si la respuesta es no, no avanzo. Puedo pedirle al asistente que lo explique, pero luego verifico esa explicación contra el código real, porque los comentarios a veces afirman cosas que la lógica no hace.
Ejecútalo en un entorno aislado
La primera ejecución debe hacerse en una rama local o en un entorno de pruebas, con datos ficticios y sin credenciales reales. Un script que borra, escribe o envía correos no debería tocar nunca tus datos de producción durante esa primera vuelta.
Consejo: Antes de editar nada, guarda el código de la IA en un commit propio con un mensaje como «código generado, sin revisar». Tus correcciones irán en commits posteriores, el diff mostrará justo lo que cambiaste y podrás revertir una pieza concreta si más adelante falla.
Errores funcionales y sintácticos habituales en el código de una IA
Los fallos más comunes del código de una IA no son errores de sintaxis evidentes, sino llamadas a funciones que no existen, versiones de librerías desactualizadas, casos límite sin cubrir y lógica que resuelve un problema parecido al tuyo. Se detectan leyendo con sospecha y probando entradas incómodas, no solo el ejemplo feliz.
Estas son las categorías que busco primero:
- Funciones o métodos inventados: el código se lee bien, pero la llamada no existe en la librería que usas.
- APIs de otra época: sintaxis válida para una versión antigua del framework que ya no encaja con la tuya.
- Casos límite ignorados: listas vacías, valores nulos, textos muy largos o fechas en otra zona horaria.
- Errores tragados: bloques try/catch que atrapan el fallo y siguen como si nada.
- Cumple el ejemplo, no el requisito: funciona con los datos del prompt y se rompe con los reales.
Un linter y el compilador atrapan la sintaxis rota. Los problemas semánticos, en cambio, solo los encuentra alguien que entiende qué debía hacer el código.
Detectar inyecciones SQL, XSS y otras vulnerabilidades
Para detectar inyecciones SQL y XSS en código de una IA, rastrea cada dato que viene del usuario hasta el punto donde se usa. Si llega a una consulta, a un comando o al HTML sin parametrizar, validar o escapar, tienes una vulnerabilidad probable, por limpio que se vea el código alrededor.
Este es el patrón que encontré en mi formulario y su corrección:
// Peligroso: el texto del usuario entra en la consulta
db.query("SELECT * FROM usuarios WHERE email = '" + email + "'");
// Correcto: consulta parametrizada
db.query("SELECT * FROM usuarios WHERE email = $1", [email]);Para XSS busco por texto las instrucciones que insertan HTML sin filtrar, como innerHTML, document.write o dangerouslySetInnerHTML. También miro eval y cualquier ejecución de comandos construida con texto externo.
Más allá de SQL y XSS, estas son las señales de alarma que reviso:
- Validación hecha solo en el navegador, sin repetirla en el servidor.
- Rutas que devuelven datos sin comprobar quién los pide.
- CORS abierto a cualquier origen sin necesidad real.
- Cookies de sesión sin las opciones de seguridad correspondientes.
- Mensajes de error que muestran trazas internas al visitante.
Herramientas gratuitas para revisar código generado por IA
Las herramientas gratuitas cubren la mayor parte de la revisión automática de código de una IA: análisis estático para el código, escáneres de secretos, auditores de dependencias y una auditoría de navegador para rendimiento. Ninguna sustituye a la lectura humana, pero detectan en segundos lo que a ti te llevaría horas.
El apéndice OWASP AI Code Generation Verification Requirements plantea la verificación como una combinación de análisis humano y herramientas automatizadas, entre ellas SAST, DAST, IAST, análisis de secretos, análisis de dependencias y escaneo de infraestructura como código. Para una web pequeña, mi selección práctica es esta:
| Qué quiero vigilar | Tipo de herramienta | Opciones gratuitas o de código abierto | Cuándo la paso |
|---|---|---|---|
| Fallos de seguridad en el código | Análisis estático (SAST) | Semgrep (edición comunitaria), reglas de seguridad de ESLint | En cada pull request |
| Comportamiento de la web en marcha | Análisis dinámico (DAST) | OWASP ZAP | Contra el entorno de pruebas |
| Claves y contraseñas | Escáner de secretos | Gitleaks, TruffleHog | Antes de cada commit |
| Paquetes con fallos conocidos | Análisis de dependencias | npm audit, pip-audit, OSV-Scanner | Tras instalar algo nuevo |
| Velocidad y SEO técnico | Auditoría de navegador | Lighthouse en Chrome DevTools | Justo antes de publicar |
Comprueba siempre las condiciones de cada herramienta, porque algunas funciones avanzadas se reservan a planes de pago. El análisis IAST y el escaneo de infraestructura como código suelen reservarse a proyectos con más piezas que una web típica.
Cuando un analizador marca algo, no lo acepto ni lo descarto a ciegas. Abro el hallazgo, entiendo por qué salta y decido. Los falsos positivos existen, y por eso la herramienta ayuda a mi criterio, no lo sustituye.
Dependencias y licencias: lo que la IA añade sin avisar
Una IA puede añadir paquetes que no necesitas, que están abandonados o que ni siquiera existen con ese nombre. Antes de instalar cualquier dependencia sugerida, comprueba que el paquete es real, que tiene mantenimiento activo y que su licencia es compatible con tu proyecto.
Mi rutina de revisión de dependencias es corta:
- Busco el paquete en el registro oficial (npm, PyPI u otro) y miro quién lo publica y cuándo se actualizó.
- Reviso el archivo de bloqueo en el diff, para ver todo lo que entró de forma indirecta.
- Ejecuto el auditor de dependencias y fijo versiones concretas.
- Leo la licencia del paquete y anoto cualquier restricción.
Un nombre de paquete inventado es un riesgo real, porque alguien podría registrarlo con código malicioso. Si el nombre me suena raro, pregunto al asistente para qué lo necesita y busco una alternativa conocida.
La licencia del código que genera la propia IA es un terreno menos firme. El marco legal sigue en discusión y las condiciones dependen de cada herramienta, así que lo prudente es leer los términos del servicio que uses y, si el proyecto es comercial, consultarlo con alguien especializado.
Claves API y contraseñas: cómo encontrarlas antes de publicar
Para encontrar secretos en el código de una IA, pasa un escáner como Gitleaks o TruffleHog sobre el repositorio y busca a mano archivos de entorno, tokens y cadenas de conexión. Hazlo antes del commit, porque una clave que entra en el historial de Git debe considerarse comprometida.
Los asistentes tienden a escribir valores de ejemplo con aspecto real, o a pegar una clave que tú les diste en la conversación. Miro tres sitios: el propio código, los archivos de configuración y los archivos .env que podrían quedar fuera del .gitignore.
Si una clave llegó a subirse, borrar el archivo no basta. Primero la revoco y genero una nueva, y después limpio el historial. Mientras la clave antigua siga activa, cualquiera que la haya copiado puede usarla.
Pruebas unitarias, de integración y de extremo a extremo
Conviene ejecutar tres niveles de prueba: unitarias para cada función, de integración para comprobar que las piezas se entienden entre sí y de extremo a extremo para recorrer la web como un visitante. Cada nivel atrapa fallos que los otros dejan pasar.
Puedes pedirle a la IA que escriba las pruebas, pero la calidad del prompt decide el resultado:
- Antes: «Escribe tests para esta función.»
- Después: «Escribe pruebas para esta función que cubran lista vacía, valores negativos, texto con comillas y un error del servicio externo, y que fallen si la función devuelve datos sin validar.»
Con el primer prompt obtengo pruebas que solo confirman el camino feliz. Con el segundo, casos que intentan romper el código.
Qué cubre cada nivel
- Unitarias (Vitest, Jest, pytest): verifican la lógica aislada.
- De integración: comprueban, por ejemplo, que el formulario escribe de verdad en la base de datos de pruebas.
- De extremo a extremo (Playwright o similar): recorren el flujo completo en un navegador real.
Rendimiento, SEO y accesibilidad
Antes de publicar paso Lighthouse y miro tres cosas: scripts que bloquean la carga, imágenes sin dimensiones ni carga diferida, y HTML sin estructura semántica. La IA suele resolver la función y olvidar encabezados, textos alternativos y etiquetas de formulario.
Cuándo no publicar y cómo dejar documentado lo que sí publicas
No publiques código de una IA si no puedes explicarlo, si toca pagos, autenticación o datos personales sin que alguien con experiencia lo haya revisado, o si las pruebas y los analizadores siguen fallando. Un retraso cuesta menos que una brecha en producción.
Cuando salta una de esas condiciones, no insisto con el mismo prompt. Reduzco el alcance, pido piezas más pequeñas que pueda revisar de una en una y reescribo a mano la parte crítica. Si el asistente sigue sin acertar, el tramo delicado lo escribo yo y dejo a la IA lo repetitivo.
Si delegas tareas largas a un agente que modifica tu repositorio, según lo que GitHub comunica públicamente, la página Responsible use of GitHub Copilot Agents recoge las consideraciones de uso responsable de estos agentes y conviene leerla para saber qué supervisión se espera de ti.
Para mantener el código después, dejo constancia en el mensaje del commit de qué partes vienen de un asistente, anoto en el README las decisiones no obvias y programo una revisión de dependencias periódica. Dentro de seis meses agradeceré saber qué código no escribí yo.
Lo esencial
- El código de una IA se acepta solo cuando una persona lo ha entendido y responde por él.
- Primero criterio humano y requisitos, después herramientas automáticas.
- Las consultas parametrizadas y el escapado de salida cierran la mayoría de las puertas a SQL y XSS.
- Los paquetes nuevos y los secretos merecen una pasada propia, separada del resto.
- Las pruebas deben intentar romper el código, no confirmar el ejemplo.
- Ante la duda sobre un tramo crítico, se reescribe a mano o no se publica.
Este método de revisión encaja si trabajas solo o en un equipo pequeño y publicas con frecuencia, porque añade controles sin exigir una infraestructura grande. Si tu proyecto maneja pagos o datos sensibles, o pertenece a un sector regulado, apóyate además en una revisión de seguridad especializada. Mi regla de decisión: cuanto más daño pueda causar un fallo, más personas deben mirar el código antes de salir.
Preguntas frecuentes
- ¿Es necesario revisar manualmente el código que genera una IA?
- Sí. Los analizadores encuentran patrones conocidos, pero no saben si el código hace lo que tu proyecto necesita. Esa comprobación solo puede hacerla una persona que conozca el requisito.
- ¿Cómo compruebo la licencia del código que me da una IA?
- Lee los términos del servicio de la herramienta que usas, porque definen qué puedes hacer con lo generado. Para las librerías que acompañan al código, revisa la licencia de cada paquete. Si el proyecto es comercial, una consulta legal evita sorpresas.
- ¿Qué checklist uso para aprobar código de una IA?
- La mía cabe en cinco preguntas: ¿cumple los requisitos?, ¿sé explicarlo?, ¿pasa los analizadores?, ¿están limpios los secretos y las dependencias? y ¿superan las pruebas los casos incómodos? Si alguna respuesta es no, el código no sale.
- ¿Cómo documento y mantengo código web creado con IA?
- Indica en los commits qué piezas vienen de un asistente, explica en el README las decisiones poco evidentes y programa auditorías de dependencias recurrentes. Así, quien lo mantenga sabrá dónde mirar con más cuidado.
- ¿Sirve pedirle a otra IA que revise el código?
- Sirve como segunda lectura, porque puede señalar descuidos que pasaste por alto. Pero comparte los mismos puntos ciegos, así que no reemplaza ni a las herramientas ni a tu criterio.

