Del MVP al despliegue: cómo llevar vibe coding a producción sin fallos

Desarrollador revisando logs de error durante una incidencia nocturna en producción

Hace catorce meses recibimos un correo a las 23:40 de un domingo. El asunto era corto: «la app está cobrando dos veces y no sé por qué». El fundador había construido su producto entero conversando con un modelo, lo había lanzado el jueves, y para el domingo llevaba 1.200 € en cargos duplicados sobre 83 clientes. Todo funcionaba. Ese era justamente el problema.

Desde entonces hemos revisado 34 proyectos de vibe coding en producción construidos con este enfoque y el patrón se repite con una monotonía casi aburrida. No fallan donde la gente teme que fallen. Fallan en cuatro sitios concretos, siempre los mismos, y ninguno tiene que ver con la calidad del modelo que generó las líneas.

Vamos a desmontarlo por partes, como un diagnóstico: síntoma, causa, prueba y tratamiento.

¿Por qué la app funciona en demo y revienta con usuarios reales?

El vibe coding (construir software describiendo lo que quieres a un modelo conversacional) no falla por la calidad de lo que genera. Falla porque una demo es un entorno controlado con un solo camino: el que tú recorres mientras grabas el vídeo. Un usuario real pulsa dos veces, abre tres pestañas y pierde la cobertura a mitad del formulario.

Durante meses creímos que era un problema de volumen. Metes más gente, se rompe. Después de las primeras doce revisiones entendimos que no: es un problema de imprevisibilidad. Trescientas personas haciendo lo mismo no rompen nada. Treinta haciendo cosas raras, sí.

El síntoma típico: todo va bien hasta el primer pico de tráfico

En uno de los casos que auditamos en marzo, la aplicación respondía en 180 ms con el fundador y dos amigos probándola. Al llegar a 300 usuarios concurrentes tras una mención en Product Hunt, la latencia media subió a 4,3 segundos. ¿Infraestructura insuficiente? No. Veintitrés consultas sin índice sobre una tabla de 14.000 filas, cada una lanzada dentro de un bucle.

El modelo había escrito algo correcto. Correcto para un registro. Catastrófico para catorce mil.

Y aquí está el quid: nadie revisó esa parte porque la parte funcionaba.

Señales tempranas que se ignoran en la revisión

Mira, lo que pasa es que las señales existen desde el día uno, solo que no tienen aspecto de alarma. Tienen aspecto de detalle menor.

  • Un endpoint tarda 900 ms en local con datos de prueba.
  • El panel de administración carga sin pedir ningún rol.
  • Hay un TODO: validar aquí que lleva seis semanas ahí.
  • Nadie sabe decir qué pasa si el usuario recarga a mitad del pago.

Cualquiera de esas cuatro líneas es un incidente futuro con fecha pendiente de asignar. En las auditorías que llevamos hechas, el 71 % de los casos presentaba al menos tres de ellas simultáneamente.

Los cuatro puntos donde se rompe el software generado con IA

De la treintena larga de proyectos que hemos abierto, 31 fallaban en al menos dos de estos cuatro frentes. Ninguno fallaba en algo distinto. Es una lista corta y eso debería ser una buena noticia.

  • Permisos y autenticación: el acceso a los datos queda abierto porque restringirlo rompería la prueba inicial.
  • Idempotencia en pagos: el mismo cobro se ejecuta dos veces cuando el navegador o el proveedor reintentan.
  • Migraciones de base de datos: renombrar una columna se traduce en borrarla y recrearla vacía.
  • Gestión de secretos: las claves privadas acaban dentro del paquete que descarga el navegador.

Permisos y autenticación: la capa que el modelo da por supuesta

Siete de cada diez productos que hemos auditado tenían Row Level Security desactivado en Supabase. No mal configurado: desactivado. Significa que cualquiera con la clave pública (que vive en el navegador de todos tus usuarios, cómo no) puede leer la tabla de clientes completa.

El modelo no lo hace por maldad ni por torpeza. Lo hace porque cuando pides «una tabla de usuarios con su plan de suscripción», activar políticas de acceso haría que tu propia consulta de prueba devolviera cero filas y parecería que no funciona. Así que no las activa. Y tú, viendo datos en pantalla, lo das por bueno.

Si quieres entender de dónde sale ese comportamiento por defecto, escribimos un desglose sobre la arquitectura por defecto de Lovable y Supabase donde explicamos qué decisiones toma el stack por ti sin avisarte. Conviene leerlo antes de abrir el acceso a nadie que no seas tú.

Añadimos un matiz incómodo: en cuatro casos las políticas sí estaban activas, pero escritas de forma que un usuario podía modificar su propio campo role. Autoascenso a administrador en una petición. Lo dimos por bueno dos veces antes de aprender a buscarlo (nadie audita la pantalla de perfil a las once de la noche).

Idempotencia: el cobro que se ejecuta dos veces

Volvamos al correo del domingo. ¿Qué había ocurrido exactamente? El endpoint de pago creaba el cargo en Stripe y después escribía el registro en base de datos. Si la escritura tardaba más de la cuenta, el navegador reintentaba. Segundo cargo.

Los proveedores de pago reintentan el envío de webhooks durante horas mientras no reciban una respuesta correcta. Si tu handler tarda demasiado en procesar, recibes el mismo evento dos veces. Tres, si tarda más. El sistema está diseñado para repetirse y tu lógica tiene que estar diseñada para soportarlo.

Una clave de idempotencia son nueve líneas. Sí, nueve. El cliente perdió 1.200 € en once días y, lo que dolió más, la confianza de 83 personas que acababan de pagarle por primera vez.

Confesión: la primera vez que nos enfrentamos a esto en 2023, nosotros tampoco lo vimos venir en la revisión inicial. Lo encontramos porque el fundador nos mandó una captura de su panel de Stripe, no porque lo buscáramos. Ahora es la pregunta número dos de nuestro checklist.

Base de datos: migraciones destructivas y borrados sin vuelta atrás

Cuando pides «renombra esta columna», muchos asistentes generan un DROP COLUMN seguido de un ADD COLUMN. Es la ruta más corta. También es la que borra el contenido de 14.000 filas sin preguntar.

En septiembre de 2024 recuperamos un producto que había perdido el historial de pedidos completo por una migración así. Había backup. Tenía 9 días de antigüedad porque la retención automática estaba en el plan gratuito.

Total, que la pregunta no es si tu migración es correcta. Es si puedes deshacerla.

Infraestructura de base de datos donde se ejecutan las migraciones de un proyecto web

Secretos y claves expuestas en el cliente

Tres de los casos analizados tenían la clave secreta de Stripe accesible desde el bundle de JavaScript. Dos tenían la service_role de Supabase, que ignora cualquier política de seguridad por diseño.

Esto ocurre por un motivo muy concreto: el asistente escribe la llamada a la API en el componente de frontend porque ahí es donde está el botón. La separación cliente/servidor es una convención de arquitectura, no una regla sintáctica, y nada marca el error en rojo.

¿Qué causa realmente estos fallos? No es el modelo, es el contexto ausente

Aquí está la parte que incomoda. Culpar a la herramienta es cómodo y es falso.

Un desarrollador sénior con diez años de experiencia produce los mismos cuatro fallos si le pides que entregue en cuatro días sin especificaciones. Lo hemos visto. La velocidad del vibe coding no crea problemas nuevos: amplifica los que ya existían en cualquier proyecto sin restricciones escritas.

El prompt describe el caso feliz y nada más

«Haz un formulario de registro que guarde el email y la contraseña.»

Eso es lo que se pide. Veamos lo que no se pide: qué ocurre si el email ya existe, si la contraseña tiene 3 caracteres, si el usuario envía el formulario catorce veces seguidas, si el proveedor de correo está caído, si alguien mete 50.000 caracteres en el campo nombre.

El modelo responde exactamente a lo que le preguntas. Es su mayor virtud y la razón por la que tu aplicación solo contempla un escenario de los seis que existen.

Código sin dueño: nadie puede defender el diseño que no escribió

Preguntamos siempre lo mismo en la primera llamada: «¿por qué esta parte está resuelta así?». En 19 de 34 casos la respuesta literal fue «no lo sé, lo generó así».

Esa frase no es un problema de conocimiento. Es un problema de propiedad. Si nadie puede explicar una decisión, nadie puede evaluar si sigue siendo válida cuando cambian los requisitos. Y los requisitos cambian siempre.

¿Significa que hay que entender cada línea? No seamos ingenuos, nadie entiende cada línea de sus dependencias. Pero sí cada frontera: dónde se valida, dónde se autoriza, dónde se escribe en disco, dónde se habla con dinero.

Deuda técnica compuesta: cada iteración parchea sobre la anterior

Esto es lo más caro y lo menos visible. Un fallo aparece, lo describes al asistente, el asistente añade una condición. El fallo desaparece. La causa, no.

Medimos una vez la evolución de un archivo concreto: en febrero tenía 140 líneas, en abril tenía 890. Las mismas funciones. Siete capas de condiciones defensivas puestas una sobre otra, varias contradictorias entre sí. Dos de ellas se anulaban mutuamente y el comportamiento final dependía del orden de carga.

¿Se puede mantener algo así a largo plazo? Sí, pero solo si las fronteras siguen siendo legibles. Cada parche individual era razonable. El conjunto era indefendible.

Cables enredados como metáfora de la deuda técnica acumulada en capas sucesivas

Diagnóstico antes de desplegar: cómo saber si tu proyecto aguanta

No hace falta una auditoría de dos semanas para saber si tienes un problema. Hacen falta veinte minutos y honestidad.

Cinco preguntas que revelan si el código es mantenible

  1. ¿Puedes nombrar los tres sitios donde se valida la entrada del usuario?
  2. ¿Qué pasa si el mismo webhook de pago llega dos veces?
  3. ¿Un usuario autenticado puede leer datos de otro usuario? Pruébalo, no lo supongas.
  4. ¿Cuánto tardas en volver a la versión de ayer?
  5. ¿Quién se entera primero de un error: tú o el cliente?

Si fallas la cuarta y la quinta, el resto da igual. Sin rollback y sin alertas, cualquier fallo se convierte en un fallo largo.

Cuando los síntomas apuntan a algo estructural y no a un bug concreto, hacemos un diagnóstico técnico de tu código que mapea exactamente estas fronteras antes de tocar nada. Es la diferencia entre operar con radiografía y operar a ciegas.

Qué revisar manualmente aunque el asistente haya escrito casi todo

Hay cuatro zonas donde la revisión humana no es negociable, y se resumen en una regla: todo lo que toque identidad, dinero, datos ajenos o borrado permanente. Da igual que, según algunas estimaciones del sector, la generación automática cubra ya el 90 % de las líneas en ciertos equipos: esas cuatro zonas siguen siendo tuyas.

Concretamente: políticas de acceso a cada tabla, el handler de cada webhook de pago, cualquier migración que contenga DROP o ALTER, y el archivo de variables de entorno comparado contra lo que realmente llega al bundle del navegador.

Son cuatro revisiones. En proyectos pequeños, unas tres horas. Hubo casos en los que ese repaso evitó pérdidas de cuatro cifras.

Tratamiento: qué cambiar en el flujo de trabajo, no en la herramienta

Si tu conclusión tras leer esto es «dejo de usar asistentes», te has llevado el mensaje equivocado. Nosotros los usamos a diario y no pensamos volver atrás. Lo que cambió fue cómo pedimos las cosas y qué miramos después.

Especificar restricciones, no solo funcionalidad

Compara estas dos peticiones.

La primera: «crea el endpoint de checkout». La segunda: «crea el endpoint de checkout; debe ser idempotente con clave en la cabecera, rechazar importes negativos, responder 200 al webhook antes de procesar, escribir el intento en una tabla de log antes de llamar al proveedor, y no exponer ninguna clave fuera del servidor».

La segunda tarda noventa segundos más en escribirse. Produce algo que no hay que reparar en marzo. Desde que lo aplicamos de forma sistemática, nuestros proyectos internos pasaron de una media de 11 incidencias en el primer mes a 2.

La clave está en pensar en el caso triste antes que en el feliz. Resulta antinatural. Funciona.

Observabilidad y rollback desde el primer despliegue

De todos los productos que hemos auditado, solo 2 tenían logs estructurados. El resto se enteraba de los errores por correo de un usuario enfadado.

Mínimo viable de instrumentación, y no es negociable aunque lleves tres días de vida: captura de errores con Sentry o equivalente (20 minutos de configuración), un log por cada operación que mueva dinero, alerta al móvil cuando el ratio de error supere el 2 %, y un despliegue anterior al que puedas volver con un comando.

Ese último punto es el que más veces hemos visto ausente. Sin él, cada publicación es irreversible y eso convierte cualquier cambio pequeño en una decisión de riesgo.

Cuándo reescribir y cuándo seguir reparando

Pregunta que nos hacen en casi todas las llamadas. La respuesta no depende del tamaño del proyecto, depende de si todavía puedes razonar sobre él.

Repara cuando los fallos son localizables: aparecen en un sitio, los arreglas en ese sitio, no reaparecen en otro. Eso indica que las fronteras siguen intactas.

Reescribe cuando cada corrección rompe algo distinto. Es el síntoma de que las capas de parches se han vuelto interdependientes y ya no hay forma de predecir el efecto de un cambio. En nuestra experiencia, ese umbral llega antes de lo que la gente cree: por debajo de las 8.000 líneas.

Y una tercera opción que casi nadie considera: rehacer solo las cuatro zonas críticas y dejar el resto. El 80 % de un MVP es formularios y listados, y esa parte puede ser mediocre sin consecuencias. Es el 20 % restante el que te cuesta dinero.

El coste oculto de arreglarlo después

Los números que manejamos son bastante estables. Blindar los cuatro puntos antes de publicar: entre 10 y 20 horas en un proyecto típico. Repararlos después de una incidencia con usuarios reales: entre 6 y 9 semanas, contando la reconstrucción de datos, la comunicación con los afectados y los reembolsos.

Pero el coste que no aparece en ninguna factura es otro. El fundador del correo del domingo tardó cuatro meses en volver a lanzar algo. No porque fuera irrecuperable, lo arreglamos en tres semanas, sino porque había perdido la confianza en su propia capacidad de publicar sin romper nada.

Eso es lo que realmente falla cuando un producto generado con asistentes llega a manos de usuarios reales sin pasar por un filtro: no se rompe la aplicación, se rompe el ritmo del proyecto.

Si estás en ese punto, mira qué hacemos con MVPs que no aguantan y decide con datos en vez de con la sensación de que algo va mal. Normalmente, algo va mal en cuatro sitios concretos y tiene arreglo.

Dicho de otro modo: el problema del vibe coding nunca fue la velocidad. Fue desplegar a esa velocidad sin haber escrito jamás lo que no debía ocurrir.

Equipo revisando la arquitectura de una aplicación en una pizarra antes del despliegue

Founder & Software Engineer
Ingeniero de Software y Desarrollador Full Stack con más de 10 años de experiencia operativa. Dirige MVPtoSaaS aplicando los mismos estándares de fiabilidad y rendimiento exigidos en sistemas industriales y de alta criticidad. El enfoque de Felipe asegura que cada producto que transita por MVPtoSaaS cuente con código limpio, bases de datos optimizadas para alta concurrencia y despliegues automatizados preparados para el crecimiento sostenido sin deuda técnica.