Estos días me topo con muchas demos tipo “monté una app completa en una tarde con IA”. Y sí: es una locura.
Pero vi la charla The Infinite Software Crisis y me dejó una idea que me persigue: si escribir código es cada vez más barato, el problema ya no es producir… es entender.
La IA multiplica velocidad. Y, si no tienes carriles, también multiplica deuda.
Lo interesante no es “usar IA o no”, sino cómo trabajas para que no te explote en 3 meses.
Table of contents
Open Table of contents
- A mí esto me pasa mucho (y seguro que a ti también)
- La “software crisis” no es nueva, solo cambia de disfraz
- La IA no arregla la complejidad: la acelera
- “Vibecoding”: cuando el código copia la conversación
- La diferencia que te salva: simple vs fácil
- La receta que me llevo: Research → Planning → Implementation
- Lo aplico mañana así (sin burocracia)
- Por acabar
A mí esto me pasa mucho (y seguro que a ti también)
Te pongo un ejemplo típico: estás en un proyecto de integración (web + sistema legacy). Empiezas con algo sencillo: “sincronizar contactos”.
Luego cae el “ya que estamos…”:
- “añade el perfil ampliado”
- “mételes agregados de pagos por año”
- “ah, y que sirva para segmentación”
- “y en el futuro para Salesforce/Meta/Ads”
- “y sin saturar el sitio, con colas y reintentos”
- “y monitorización”
- “y, ya que estamos, que sea replicable para otros proyectos”
Todo eso suena razonable… hasta que te das cuenta de que has convertido una tarea de sincronización en una plataforma.
La IA aquí es peligrosa por una razón: hace que el “ya que estamos…” sea demasiado fácil.
La “software crisis” no es nueva, solo cambia de disfraz
El concepto de “software crisis” lleva décadas rondando: sistemas que crecen más rápido que nuestra capacidad de diseñarlos, mantenerlos y operarlos.
Cada época encuentra una “solución”… y a la vez abre la puerta a construir todavía más grande.
Antes era el monolito. Luego capas, frameworks, microservicios, eventos…
Ahora: prompts y generación acelerada.
La crisis no se fue. Solo se modernizó.
La IA no arregla la complejidad: la acelera
La idea central del vídeo me parece muy honesta: la IA no elimina el coste real del software. Solo hace más barato producir cambios.
Pero el “coste real” sigue ahí:
- alguien tiene que operarlo
- alguien tiene que depurarlo
- alguien tiene que entender por qué se decidió X
- alguien tiene que pagar el mantenimiento durante años
Si la IA te permite meter 50 cambios donde antes metías 10… pero sin orden… el resultado es predecible: más superficie, más acoplamiento, más fragilidad.
“Vibecoding”: cuando el código copia la conversación
Hay un concepto que me hizo gracia y me pareció muy real: vibecoding.
Es cuando construyes a base de conversación (prompt tras prompt) y el sistema termina siendo exactamente eso: una conversación pegada con cinta adhesiva.
Sí, “funciona”.
Pero luego pasa esto:
- nadie sabe el mapa del sistema
- aparecen decisiones accidentales (“esto está así porque un día fallaba en staging”)
- cada cambio nuevo rompe algo distinto
Y aquí viene la trampa: como la IA arregla rápido, parece que no hay problema… hasta que el sistema ya es inmanejable.
La diferencia que te salva: simple vs fácil
Esto lo quiero subrayar porque es el corazón del asunto:
- Fácil: seguir generando parches sin parar (“añade auth”, “añade caché”, “añade excepciones”, “añade flags”…).
- Simple: parar, poner límites y construir por fases, con objetivos claros.
La IA hace lo fácil demasiado tentador.
Pero lo simple es lo que te da un sistema que puedes seguir tocando dentro de 6 meses sin miedo.
La receta que me llevo: Research → Planning → Implementation
La propuesta práctica del vídeo es muy clara: trabajar en tres fases.
1) Research: entender antes de producir
Objetivo: comprimir el problema.
- ¿Qué es “un contacto” en este dominio?
- ¿Qué campos son fuente de verdad?
- ¿Qué pasa cuando el dato cambia o desaparece?
- ¿Qué es imprescindible para la fase 1?
Salida mínima: un mapa del dominio + flujos principales + restricciones.
2) Planning: definir límites y contratos
Objetivo: dibujar fronteras.
- qué hace cada componente
- qué contratos hay (API/eventos)
- qué riesgos existen
- cómo harás rollout / rollback
Salida mínima: un plan que permita implementar sin improvisar a cada paso.
3) Implementation: ejecutar dentro del carril (aquí sí, IA a tope)
Objetivo: tareas pequeñas, medibles, y con contexto estable.
Aquí la IA es una bestia: te acelera tests, scaffolding, endpoints, migraciones…
pero sin convertir el diseño en un “prompt infinito”.
Lo aplico mañana así (sin burocracia)
Si tuviera que convertirlo en hábitos concretos:
- Define límites en 15 minutos: “Esto sincroniza perfiles, no crea un CRM.”
- Escribe 10 bullets de “éxito”: Qué debe pasar / qué NO debe pasar
- ADRs mini (1 párrafo): “Elegimos cola X por Y; descartamos Z por W”
- Observabilidad desde el día 1: logs útiles + métricas mínimas + alertas básicas
- Entrega reversible: flags, rollback plan
- Reviews contra complejidad: no solo “pasa tests”: “¿esto simplifica o añade lío?”
Por acabar
La IA no es el enemigo.
El enemigo es construir sin límites y confiar en que “ya lo arreglaremos luego” porque ahora todo se genera rápido.
En la era del “código infinito”, la ventaja competitiva no es escribir más.
Es saber qué no construir, poner fronteras, y mantener lo bastante simple como para que un humano lo entienda.
Pregunta para ti: ¿en tu equipo la IA está simplificando… o está acelerando la deuda?