Verificación de aceptación: cómo revisar el código escrito por IA antes de publicarlo
Primero la respuesta: la revisión de código con IA no es descifrar el código línea por línea, sino recorrer una lista de cuatro pasos — mirar el diff, ejecutar las pruebas, pasar las líneas rojas de seguridad y saber explicarlo. Tras completar estos cuatro pasos, «parece que no hay problemas» se convierte en «verificado».
¿Por qué este paso es imprescindible? Recuerda la práctica descrita en aquel tuit tan difundido de Karpathy: «I "Accept All" always, I don't read the diffs anymore» — siempre lo acepto todo, ya no leo los diffs. También admitió: «The code grows beyond my usual comprehension» — el código ha superado su capacidad habitual de comprensión. La definición de vibe coding del ingeniero Simon Willison es igual de directa: «building software with an LLM without reviewing the code it writes» — construir software con un LLM sin revisar el código que escribe.
Así que «revisar o no revisar» es la línea divisoria entre vibe coding y el desarrollo de software serio: un juguete de fin de semana para entretenerse puede publicarse sin mirar el diff; lo que va a lanzarse, la revisión es obligatoria. Esta lección es precisamente la cuarta disciplina establecida en la guía del flujo de trabajo: «verificación antes del lanzamiento» — ejecutar pruebas de pasa/no pasa y saber explicar qué hace el código.
Aplicable a cuatro herramientas (Claude Code, Codex, OpenCode, WorkBuddy), se completa en 10 minutos sin conocimientos previos.
Qué podrás hacer al terminar
- Verificar el código entregado por la IA con una lista de aceptación de cuatro pasos: mirar el diff, ejecutar pruebas y exigir evidencia, pasar las líneas rojas de seguridad y saber explicarlo, convirtiendo «parece que no hay problemas» en «verificado»
- Saber decir qué se revisa prioritariamente en la revisión de código de IA: las zonas de mayor incidencia de errores lógicos, errores de configuración y vulnerabilidades de seguridad señaladas por investigaciones cuantitativas, verificadas punto por punto
- Usar las funciones de revisión integradas en las herramientas para que «una IA que no escribió ese código» te ayude a revisarlo:
/code-reviewy/security-reviewde Claude Code, la revisión dedicada de Codex, el comando review-diff de OpenCode - Distinguir cuándo puedes usar el estilo original de «no mirar el diff» y cuándo debes hacer la verificación — lo que otros van a usar debe ser revisado por alguien con experiencia antes de publicarse
Tu situación actual
- La IA dice «completado, todas las funciones funcionan con normalidad», abres la página y efectivamente corre — pero de paso modificó tres archivos que no le pediste tocar, y tú no lo sabes en absoluto
- Has oído que el código escrito por IA tiene 2.74 veces más vulnerabilidades de seguridad que el escrito por humanos, quieres revisarlo pero no sabes por dónde empezar: no entiendes el código, ¿qué se revisa exactamente en la revisión de código de IA y en qué orden?
- Tu producto está a punto de ser usado por otros (amigos, clientes, publicación en tiendas) y no te sientes seguro: si esconde una vulnerabilidad, ¿quién la descubrirá primero, un usuario o un atacante?
Cuándo usar esta técnica
Cuando necesitas:
- Convertir «la IA dice que está hecho» en «verificado, listo para lanzar»
- Lo que otros van a usar, retener los riesgos en tus manos antes de publicarlo
- Una lista de verificación de código de IA que puedas ejecutar sin entender de código
Y no quieres:
- Descifrar línea por línea cada línea de código generada por la IA (esta lección no exige que lo entiendas todo)
- Descubrir vulnerabilidades después del lanzamiento gracias a los errores reportados por usuarios
- Trasladar directamente el estilo «Accept All» de los juguetes de fin de semana a un producto serio
🎒 Preparativos antes de empezar
- Haber leído Bucle de errores: devuelve el mensaje de error tal cual — los problemas detectados en la verificación terminan volviendo al bucle de reparación de esa lección
- Tener instalada y haber usado al menos una herramienta: Claude Code, Codex, OpenCode o WorkBuddy
- Tener a mano un pequeño proyecto «que corre» recién entregado por la IA — practicar con entregables reales se recuerda mejor que ver ejemplos
- 10 minutos y un vaso de agua ☕
Idea central
La esencia de la verificación de aceptación: convertir «parece hecho» en «las pruebas demuestran que está hecho». Las mejores prácticas oficiales de Claude Code lo dejan muy claro: sin pruebas ejecutables, la única base de la IA para dar por terminado el trabajo es «parece hecho» — en realidad tú te conviertes en su suite de pruebas, y cada problema solo se expone en el momento en que lo ejecutas personalmente.
¿Y por qué no basta con «ejecutarlo y ver»? Porque las investigaciones cuantitativas han puesto sobre la mesa los problemas de calidad del código de IA:
| Investigación | Hallazgo | Qué significa para la aceptación |
|---|---|---|
| CodeRabbit (2025-12, análisis de 470 PR de código abierto en GitHub) | El código con participación de IA tiene aproximadamente 1.7 veces más problemas «graves» que el escrito por humanos; un 75% más de errores de configuración; 2.74 veces más vulnerabilidades de seguridad | No basta con ver si la funcionalidad corre, hay que verificar por muestreo según las zonas de mayor incidencia |
| Veracode (2025-10, seguimiento de tres años) | La capacidad de los modelos para generar código ejecutable ha mejorado notablemente, pero la seguridad del código generado no ha mejorado en conjunto | «El modelo se actualizó, debería ser más seguro» no se cumple: cada lote de código debe revisarse |
| Incidente de Lovable (2025-05) | De 1,645 aplicaciones web creadas con Lovable, una plataforma de aplicaciones con IA, 170 presentaban el defecto de seguridad de que «cualquiera podía acceder a los perfiles de usuario» | Sin verificación, las vulnerabilidades aparecen por lotes al publicar |
El contexto completo de estas cifras se detalla en Vibe Coding ¿Es fiable? Riesgos, controversias y casos reales. Esta lección solo toma una cosa: los problemas de calidad del código de IA no son aleatorios, tienen zonas de mayor incidencia — errores lógicos, errores de configuración y vulnerabilidades de seguridad. La lista de verificación está diseñada precisamente según esas zonas.
Un adelanto de la lista de cuatro pasos, cada uno bloquea un tipo de problema:
| Paso | Acción | Qué bloquea |
|---|---|---|
| 1. Ver el diff | revisar una por una los cambios de la IA | que haya cambiado cosas que no le pediste |
| 2. Ejecutar las comprobaciones | comprobaciones que pasan/no pasan + comandos y salidas como evidencia | el falso completado de «parece que está hecho» |
| 3. Pasar las líneas rojas | verificar una por una claves, permisos, configuración y lógica | zonas de alta incidencia de vulnerabilidades de seguridad y errores de configuración |
| 4. Poder explicarlo | poder explicar a otra persona qué hace el código y, si hace falta, pedir a alguien que lo revise | poner en producción código que ni tú mismo entiendes |
Una frase para recordar esta lección: hay que ver el diff, ejecutar las comprobaciones, pasar las líneas rojas y solo subir a producción lo que puedas explicar.
Hazlo conmigo
(Toma como material ese proyecto que la IA acaba de entregar, y recorre los cuatro pasos: desde ver con claridad qué cambió, hasta tener la confianza para subirlo a producción. Cualquier problema que encuentres, pégalo de vuelta en el bucle de errores para arreglarlo.)
Paso 1: ver el diff — la revisión de código de IA empieza por «qué cambió»
Por qué: que lo que produce la IA no coincida con lo que pensabas es la trampa más común de la lista de mejores prácticas oficiales — no puede leer los requisitos de tu cabeza, solo puede adivinar. Y «aceptar todo sin mirar el diff» deja escapar justamente todas las oportunidades de descubrir que adivinó mal. Por eso el primer paso de la revisión de código de IA no es leer el código, sino ver la lista de cambios: primero saber qué archivos tocó, y después hablar de comprobaciones.
Cómo ver los cambios en cada herramienta:
| Herramienta | Cómo ver el diff |
|---|---|
| Claude Code | ejecutar /diff en la sesión, para ver los cambios del espacio de trabajo, incluidas todas las ediciones hechas por la IA hasta el momento |
| Codex | revisar comandos y diff en el momento en que aparecen los cambios (posición oficial: Steer the active turn, inspect commands and diffs as they appear) |
| OpenCode | ejecutar git diff --stat en la terminal para ver la lista de archivos cambiados, git diff para ver el contenido concreto |
| WorkBuddy | la entrega se devuelve en forma de «resultado verificable»; el escenario de desarrollo de código ya incluye review, así que verifica punto por punto en la conversación de la tarea qué hizo |
Si el proyecto está en un repositorio Git, git status y git diff funcionan en las cuatro herramientas — es la entrada de respaldo más básica.
Al mirar, hazte solo tres preguntas:
- ¿Todos los archivos cambiados son los que le pedí cambiar?
- ¿Hay archivos de más, dependencias de más?
- Entre las líneas eliminadas, ¿hay alguna que no parezca un «refactor»?
Los cambios de origen desconocido, pregúntaselos directamente (la primera plantilla mágica de esta página):
¿Qué archivos has modificado en esta entrega? Explica una por una qué hace cada cambio y
a qué requisito mío corresponde. ¿Hay algún sitio que hayas cambiado de paso, fuera de lo que te pedí explícitamente?💡 Deja que la IA marque los riesgos ella misma
En el flujo de trabajo oficial hay una práctica ya lista: antes de enviar, pide a la IA que señale los riesgos potenciales y los puntos a vigilar (Review Claude's generated PR before submitting and ask Claude to highlight potential risks or considerations). Su autoevaluación no sustituye tu revisión, pero te orienta — donde ella marca, es donde tú debes mirar con más atención.
Deberías ver: una lista de cambios + la explicación de la IA sobre cada cambio. Si aparece un archivo que no le pediste tocar, su explicación debe convencerte; los cambios que no pueda explicar, o los hace revertir, o los marcas como pendientes de revisar.
- Comprobación rápida: he visto la lista de archivos cambiados y no hay cambios de origen desconocido; si los hay, la explicación de la IA me convence
Paso 2: ejecutar las comprobaciones que pasan/no pasan — evidencia, no «está hecho»
Por qué: «la página se abre» no equivale a «está hecho». La lección del bucle de errores aplicaba las «comprobaciones que pasan/no pasan» a arreglar bugs; en la aceptación son la última compuerta: la entrega tiene que haber pasado de verdad las comprobaciones, y además tienes que ver la evidencia con tus propios ojos. Palabras oficiales: «"All tests pass" por sí solo no demuestra nada» — lo que se exige son los comandos que ejecutó y la salida completa.
La comprobación puede ser cualquiera de estas (lista oficial, usa las que haya en tu proyecto):
| Comprobación | Ejemplo |
|---|---|
| Tests | el comando de tests del proyecto, todos pasan |
| Build | el código de salida del comando de build/compilación es 0 |
| Lint | la herramienta de análisis de código no da errores |
| Script de comparación | la salida coincide línea por línea con el archivo esperado |
| Captura de la página | el aspecto real al ejecutarse en el navegador, comparado con lo que quieres |
Copia directamente el prompt de aceptación (la segunda plantilla mágica de esta página):
Aceptación de la entrega: pégame los comandos de comprobación que ejecutaste y la salida completa,
Incluidos: <测试命令>, <构建命令>.
Si algo no pasa, explica el motivo y el plan de arreglo; no digas solo «completado».Con Claude Code hay un as extra: cuando diga que terminó, ejecuta /verify — esta habilidad oficial hace que construya y ejecute tu aplicación y mire el resultado en persona, especializada en cazar problemas que los tests y el type checking no detectan (pantallas en blanco, botones que no responden: esos pozos de «todos los tests en verde pero la cosa no funciona»).
Deberías ver: la IA pega de vuelta los comandos que ejecutó y la salida completa; tú eliges uno y lo reejecutas, con el mismo resultado. Si no coincide, es que no lo ejecutó o ejecutó otra cosa — de vuelta al bucle de errores.
- Comprobación rápida: tras las palabras «está hecho» siguen comandos y salidas, y yo mismo reejecuté al menos uno
Paso 3: repasar las líneas rojas de seguridad — verificar una por una las zonas de alta incidencia de la calidad del código de IA
Por qué: la investigación de CodeRabbit da la distribución de problemas del código con participación de IA — los errores de lógica (dependencias erróneas, defectos de flujo de control) tienen mayor proporción, los errores de configuración son un 75% más, y las vulnerabilidades de seguridad 2.74 veces más. La revisión de código de IA no puede repartir el esfuerzo por igual: hay que revisar punto por punto según las zonas de alta incidencia. Cuatro líneas rojas, cada una con su forma clara de comprobarse:
| Línea roja | Qué comprobar | Por qué es zona de alta incidencia |
|---|---|---|
| 1. Claves | si alguna API key, contraseña o token quedó hardcodeada en el código o enviada al repositorio | punto 2 de la lista de seguridad de Willison: en cuanto el código involucra claves, hay que entenderlo, o es fácil que se filtren |
| 2. Permisos | si siguen en pie las barreras de «quién puede acceder a qué»: login, autorización, alcance de visibilidad de datos | incidente de Lovable: en 170/1,645 aplicaciones cualquiera podía ver los datos de usuarios — los agujeros de permisos aparecen en lote |
| 3. Configuración | si los valores de configuración son correctos y si producción/test no se han confundido | CodeRabbit: en código con participación de IA hay un 75% más de errores de configuración |
| 4. Lógica | si el flujo de control de los procesos núcleo es correcto: condiciones, bordes, manejo de excepciones | CodeRabbit: los errores de lógica (dependencias erróneas, defectos de flujo de control) tienen mayor proporción |
Aunque no entiendas de código, puedes verificar las dos primeras: la línea roja de claves, busca globalmente en el proyecto palabras como key, secret, token, password; si hay coincidencias, pide a la IA que explique qué son y si se harán públicas junto con el código; la línea roja de permisos, accede una vez con «la cuenta de otra persona» o sin iniciar sesión; si ves algo que no deberías ver, hay una vulnerabilidad. Las dos últimas quedan cubiertas por la revisión con herramientas:
| Herramienta | Comando de revisión |
|---|---|
| Claude Code | /code-review revisa la corrección y los bugs del diff actual (alias /review, con --fix aplica las correcciones directamente); /security-review revisa específicamente vulnerabilidades de seguridad — inyecciones, problemas de autenticación, exposición de datos |
| Codex | revisión especializada: ejecuta la revisión sobre cambios sin confirmar, un commit concreto o la rama base, informa los problemas ordenados por prioridad y no toca tu área de trabajo |
| OpenCode | comando de ejemplo oficial review-diff: mete automáticamente la salida de git diff --stat && git diff en el prompt de revisión (ver trucos avanzados más abajo) |
⚠️ El informe de revisión de la herramienta no es palabra sagrada
La documentación oficial lo advierte expresamente: un revisor al que se le pide encontrar problemas, siempre encontrará algo. Si el informe de revisión lista una docena de puntos, no los corrijas todos sin más — el coste de corregir de más es acabar con un montón de capas de abstracción inútiles y pruebas de escenarios que nunca ocurrirán. Prioriza según «impacto en corrección y seguridad»: lo relacionado con las líneas rojas hay que tratarlo, lo de estilo se perdona.
Deberías ver: las cuatro líneas rojas con respuesta punto por punto; la revisión con herramientas completada, sin fallos graves como fugas de claves, permisos ausentes o vulnerabilidades de alto riesgo. Pega los problemas encontrados tal cual de vuelta al bucle de errores para corregirlos — texto del error, comando de comprobación, pedir evidencia: aplica íntegramente toda la estrategia de aquella lección.
- Pequeña comprobación: he repasado una por una las cuatro líneas rojas de claves, permisos, configuración y lógica, y los problemas encontrados ya los he pegado de vuelta al bucle de errores
Paso 4: solo cuenta si lo puedes explicar bien — lo que otros van a usar necesita que alguien lo supervise
Por qué: la regla de oro de Willison: «My golden rule for production-quality AI-assisted programming is that I won't commit any code to my repository if I couldn't explain exactly what it does to somebody else» — si no puedes explicar con precisión a otra persona qué hace un fragmento de código, no lo subas al repositorio. También dio un criterio de frontera: si el código lo escribió un LLM, pero tú lo has revisado, probado a fondo y puedes explicar a otros cómo funciona — entonces no es vibe coding, es desarrollo de software en toda regla.
La operación tiene dos niveles, elige según el destino del proyecto:
Primer nivel: explicártelo a ti mismo (todos los proyectos). Dale el diff o los archivos clave a la IA para que te lo explique (la tercera plantilla mágica de esta página):
Explícame en lenguaje llano la lógica central de estos cambios: este proyecto ahora, de principio a fin,
¿qué hace? ¿De dónde vienen los datos y adónde van? ¿Qué cambios son los más críticos y por qué?
Supón que no entiendo nada de código.Donde no lo entiendas, ahí está el riesgo — o pregunta hasta entenderlo, o márcalo para revisarlo con especial atención. Este paso solo cuenta como superado si puedes explicar el proyecto con tus propias palabras.
Segundo nivel: supervisión independiente (proyectos que otros van a usar). Punto 6 de la checklist de seguridad de Willison, textualmente: «If you're going to vibe code anything that might be used by other people, I recommend checking in with someone more experienced for a vibe check» — si vas a vibe code cualquier cosa que otras personas puedan usar, pide a alguien con más experiencia que le eche un vistazo. Si no encuentras a nadie, al menos haz que «una IA que no participó en escribir este código» actúe como revisora independiente:
- El comando
/code-reviewde Claude Code se basa justo en este principio — abre un subagente totalmente nuevo para revisar el diff, que nunca ha visto vuestra conversación y no se deja sesgar por el razonamiento de cuando se escribió el código - Con herramientas que no tienen este comando, abre una segunda sesión para hacer lo mismo: una sesión escribe el código, la otra revisa los archivos, y pegas los hallazgos en la primera sesión para corregirlos
Deberías ver: que puedes explicar en dos o tres frases sencillas «qué hace este proyecto y cómo»; para los proyectos que otros van a usar, que una persona con experiencia o un revisor independiente le ha echado una pasada.
- Pequeña comprobación: puedo explicarle a un amigo qué hace este código; para los proyectos que otros van a usar, he asignado a una persona o a una revisión independiente como filtro
Punto de control ✅
- He revisado la lista de cambios de la IA (diff), sin cambios de origen desconocido
- «Está terminado» tiene evidencia: comando de comprobación + salida completa, y yo he vuelto a ejecutar al menos uno
- Las cuatro líneas rojas de seguridad — claves, permisos, configuración y lógica — superadas una por una
- Puedo explicar con mis propias palabras qué hace el código, y he resuelto lo que no sabía explicar
- Lo que otros van a usar, lo ha visto alguien con experiencia, o ha pasado el filtro de una revisión independiente (
/code-review, segunda sesión)
Aviso de trampas comunes
❌ «La página se abre, aceptación superada»
Que la página se abra solo demuestra que la ruta principal no está rota, no demuestra nada más. Palabras textuales de las mejores prácticas oficiales: sin comprobaciones ejecutables, el criterio con el que la IA da por terminado el trabajo es «parece hecho» — tú te conviertes en su suite de pruebas, cada problema se queda latente hasta que lo ejecutas tú mismo y explota, y un atacante no va a limitarse a la ruta principal. Forma correcta: ejecuta una vez las comprobaciones de pasa/no pasa del paso 2, exigiendo comandos y salidas como evidencia; con Claude Code añade además un /verify, para que levante la aplicación por su cuenta y vea el resultado.
❌ Tomar «la IA dice que todas las pruebas pasaron» como evidencia
«"All tests pass" por sí solo no demuestra nada» — esta frase es textual de la documentación oficial. Los resultados que la IA transmite pueden ser de una ejecución real, pueden ser adivinados, o puede haber ejecutado una versión antigua del código. Forma correcta: pide que pegue los comandos ejecutados y la salida completa, y tú elige uno y vuelve a ejecutarlo para contrastar el resultado. Si la evidencia no cuadra, devuélvelo al bucle de errores.
❌ El informe de revisión listaba 15 puntos y me quedé toda la noche corrigiéndolos todos
Un revisor al que se le pide encontrar problemas siempre encontrará algo — la documentación oficial advierte expresamente de esto. El coste de corregirlo todo es acabar con un montón de capas de abstracción inútiles y pruebas de escenarios que nunca ocurrirán, y el código se vuelve más difícil de explicar. Forma correcta: prioriza según «impacto en corrección y seguridad» — lo relacionado con claves, permisos, configuración y lógica es obligatorio, lo de estilo se perdona; al corregir, arregla solo los fallos graves de uno en uno y vuelve a ejecutar las comprobaciones al terminar.
❌ Llevar sin más el método del juguete de fin de semana a un producto que otros van a usar
El propio Karpathy trazó la frontera: este método de «Accept All sin mirar el diff» funciona bastante bien para un throwaway weekend project (proyecto desechable de fin de semana). Aplicarlo tal cual a algo que otros van a usar equivale a entregar directamente a los usuarios un factor de vulnerabilidades de seguridad 2.74 veces mayor — así nacieron las 170 aplicaciones de la plataforma Lovable con «cualquiera puede acceder al perfil del usuario». Forma correcta: fija la intensidad de la aceptación según «quién lo va a usar»: para uso personal, que funcione + un vistazo rápido a las claves; para lo que otros van a usar, los cuatro pasos completos y además que alguien con experiencia lo supervise.
Trucos avanzados (opcional)
Escribe los criterios de aceptación en el manual del proyecto. Las mejores prácticas oficiales dicen: si el proyecto ya tiene comprobaciones, la línea más útil de CLAUDE.md es el comando para ejecutarlas. Escribe en AGENTS.md / CLAUDE.md «qué comprobaciones deben ejecutarse antes de la entrega y cómo entregar la evidencia», y cada sesión nueva llevará automáticamente los criterios de aceptación — la forma de escribirlo se detalla en AGENTS.md y CLAUDE.md: deja a la IA un manual del proyecto.
El comando review-diff para usuarios de OpenCode. La documentación oficial da un ejemplo de comando personalizado listo para usar: crea en el proyecto .opencode/commands/review-diff.md, con dos líneas de contenido — Review this diff: más !`git diff --stat && git diff`. Después, cada vez que ejecutes /review-diff, meterá automáticamente los cambios en el prompt de revisión.
Haz que las comprobaciones intercepten automáticamente. Claude Code admite Stop hooks: cuando Claude quiera dar por terminado el trabajo, ejecuta primero tu script de comprobación (por ejemplo, el chequeo de tipos); si no pasa, lo manda de vuelta a seguir corrigiendo — la aceptación pasa de «humano vigilando» a «mecanismo interceptando». Es un uso avanzado; si te interesa, mira la sección Enforce the check del documento oficial de best-practices.
Lectores que van por la vía de publicar un miniprograma o un plugin: la revisión de la plataforma es la última aceptación externa — antes de enviar un miniprograma de WeChat a revisión existe una checklist oficial de autoevaluación (nombre conforme a las normas, funciones centrales, seguridad del contenido), ver Envío a revisión y publicación: guía para evitar las trampas de las reglas de revisión de WeChat; para la revisión de la Chrome Web Store y los lanzamientos graduales, ver Revisión y estrategia de publicación en la tienda.
Resumen de esta lección
✅ Has completado la cadena completa de la revisión de código con IA: mirar el diff (repasar punto por punto la lista de cambios) → ejecutar las comprobaciones (pasa/no pasa + la salida del comando como evidencia) → pasar las líneas rojas (secretos, permisos, configuración y lógica, las cuatro zonas de mayor incidencia) → saber explicarlo (poder explicárselo a otra persona; lo que vaya a usar otra persona, buscar además a alguien que lo supervise).
✅ Ya sabes por qué la aceptación no se puede omitir: la investigación cuantitativa de CodeRabbit dice que el código con participación de IA tiene 2.74 veces más vulnerabilidades de seguridad que el escrito por humanos y un 75% más errores de configuración; el seguimiento de tres años de Veracode dice que la capacidad de los modelos sube, pero la seguridad no. Los problemas tienen zonas de alta incidencia, y la lista está diseñada precisamente siguiendo esas zonas.
✅ Has distinguido los límites de uso de los dos enfoques: la versión original de Karpathy, «sin mirar el diff», queda para juguetes de fin de semana; para lo que va a salir a producción, la revisión es la línea divisoria entre vibe coding y el desarrollo de software; Willison lo dice sin rodeos: si está revisado, probado y sabes explicarlo, no es vibe coding, es desarrollo de software.
Repaso de los conceptos clave:
| Concepto | En una frase | Dónde profundizar |
|---|---|---|
| Mirar el diff | Primer paso de la aceptación: saber primero qué cambió la IA | Paso 1 de esta página |
| Exigir evidencia | Comando + salida, no un simple «ya está hecho» | Paso 2 de esta página |
| Líneas rojas de seguridad | Secretos, permisos, configuración y lógica: las zonas de alta incidencia del código de IA | Paso 3 de esta página |
| Saber explicarlo | Si no puedes explicarlo, no lo confirmes: la regla de oro | Paso 4 de esta página |
| Supervisión | Lo que vaya a usar otra persona, pide a alguien con experiencia o una revisión independiente que le eche un vistazo | Paso 4 de esta página |
Vista previa de la próxima lección
Con la lista de aceptación completada, el código puede salir a producción con tranquilidad, pero espera: en esta lección las líneas rojas solo comprobaron «si los secretos están escritos en el código», y todavía no se ha tratado «cómo guardar los secretos en sí». Próxima lección: Costos y seguridad: secretos, facturas y sandbox, tres líneas de defensa.
Aprenderás:
- Cómo guardar las claves API: esta lección comprueba fugas, la próxima te da un plan completo de custodia
- Cómo establecer límites de facturación: cómo prevenir tragedias como facturas de miles de dólares generadas por vibe coding con APIs sin límite de gasto
- Cómo usar el sandbox: trazar un perímetro de actividad para la IA; la seguridad del principiante empieza con el sandbox
- Cómo supervisar la privacidad de los datos: confirmar si tus datos salen o no de tu máquina