Armin Ronacher: el código avanza aunque el equipo ya no se entienda

El 13 de julio de 2026, Armin Ronacher publicó un ensayo que compara el vibe coding con la Torre de Babel: no porque el código deje de compilar, sino porque los equipos pueden seguir construyendo incluso después de perder el idioma técnico que compartían.

Ronacher, creador de Flask, Jinja2 y Click, y hoy ingeniero en Sentry, argumenta que los agentes de IA eliminan la fricción que antes obligaba a sincronizar el entendimiento de un sistema entre personas distintas. El resultado, según él, es una torre que sigue creciendo aunque nadie pueda explicarla completa.

TL;DR

• Armin Ronacher publicó "The Tower Keeps Rising" el 13 de julio de 2026 en su blog personal, lucumr.pocoo.org.- El ensayo usa La Torre de Babel de Pieter Bruegel el Viejo como metáfora central del vibe coding sin salvaguardas.- Cita Génesis 11:3-6 (KJV): Dios no quita los ladrillos ni el conocimiento, quita el idioma compartido y la obra se detiene.- Tesis central: los agentes de IA no sienten la fricción de coordinación que antes sincronizaba a los equipos humanos.- A diferencia de Babel, el código con IA sigue avanzando aunque el entendimiento compartido ya haya colapsado.- Ronacher es el creador de Flask, Jinja2 y Click, proyectos base del ecosistema Pallets en Python.- El ensayo está licenciado bajo Creative Commons Attribution-NonCommercial 4.0 International.- Conclusión del autor: la torre no se cae, por eso nadie nota lo que se perdió hasta que ya es tarde.

Introducción

Armin Ronacher no es un comentarista externo del ecosistema de IA aplicada a la programación. Es el autor original de Flask, el framework web de Python que popularizó el enfoque minimalista frente a Django, y también creó Jinja2 y Click, dos piezas que hoy corren silenciosamente dentro de miles de proyectos. Actualmente trabaja en Sentry y escribe con regularidad sobre el impacto de los agentes de IA en la ingeniería de software, bajo la etiqueta "ai" de su blog.

Su ensayo del 13 de julio, titulado "The Tower Keeps Rising", parte de una observación cotidiana: el código generado con vibe coding cambia, en sus palabras, "de forma algo aleatoria e inesperada". Esa frase disparó en él la comparación con "La Torre de Babel" de Pieter Bruegel el Viejo, un cuadro que muestra la construcción ya en un estado caótico.

Qué pasó: la promesa del vibe coding sin fricción

El relato bíblico que cita Ronacher (Génesis 11:3-6) empieza con una mejora tecnológica: los constructores descubren cómo hacer ladrillos cocidos y usan asfalto como mortero. Con esa tecnología nueva se proponen un proyecto civilizatorio: una ciudad y una torre cuya cima llegue al cielo. Cuando Dios evalúa la situación, no le preocupan los ladrillos: le preocupa que el pueblo es uno, y todos tienen un mismo lenguaje, y nada les impedirá hacer lo que se propongan.

Para Ronacher, la fuente de poder de los constructores de Babel no era el material, era la coordinación. Un idioma compartido les permitía combinar su trabajo en algo que ninguno podría construir solo. Por eso Dios no retira los ladrillos ni el conocimiento de cómo hacerlos: retira la capacidad de entenderse entre ellos, y ahí se detiene la obra.

Trasladado al vibe coding, el argumento es el siguiente: la idea atractiva es que los agentes de IA son mejores herramientas que permiten construir software más ambicioso. Eso es cierto a nivel individual, un desarrollador con un agente cambia una base de código mucho más rápido. Pero los proyectos grandes nunca estuvieron limitados solo por la velocidad de un individuo para producir código. Estuvieron limitados por qué tan bien podían coordinar su entendimiento del sistema que estaban cambiando.
Bruegel pintó la torre ya caótica: la ambición ya superaba la coordinación.

Contexto e historia: el idioma que no es código

Ronacher aclara algo importante: el idioma compartido de un proyecto de software no es Python ni inglés. Es el entendimiento común de qué significan sus conceptos, dónde están los límites, qué invariantes importan, quién es dueño de qué parte, y por qué el sistema tiene la forma que tiene. Ese conocimiento casi nunca vive en un solo lugar. Vive parcialmente en documentación y código, pero también en revisiones de código, conversaciones, discusiones, y en la experiencia de tener que explicarle un cambio a otra persona.

Antes de los agentes, buena parte de ese entendimiento compartido se mantenía por fricción. Si alguien quería modificar la capa de almacenamiento de otro equipo, normalmente tenía que leer su código, hacerle preguntas, y quizás coordinar con otro equipo cuyo servicio dependía de esa capa. Ese proceso era lento, y buena parte de esa lentitud era desperdicio, pero no toda: parte de esa lentitud era el mecanismo por el cual el entendimiento de una persona se convertía en el entendimiento de otra.

Esta dinámica no es nueva en ingeniería de software: es la misma tensión que describe la Ley de Conway, la idea de que la arquitectura de un sistema termina reflejando la estructura de comunicación de la organización que lo construye. Los procesos de RFC, las revisiones de código obligatorias y los equipos con dueños claros de cada módulo existen, en parte, para forzar esa sincronización antes de que el código llegue a producción.

Detalles técnicos: qué significa "idioma compartido" en la práctica

Los agentes de IA eliminan buena parte de esa fricción. Una persona le puede pedir a un agente que agregue OAuth, otra le puede pedir que agregue una capa de cache, y una tercera le puede pedir que reconstruya la base de datos desde cero. Cada cambio puede ser razonable de forma aislada. El código compila, los tests pasan, y las explicaciones se generan bajo demanda. Ninguno de los tres necesita hablar con los otros, ni siquiera necesita adquirir la parte del modelo mental que ese cambio antes habría forzado a aprender.

💭 Clave: Ronacher no dice que los agentes de IA generen peor código. Dice que eliminan la fricción que antes sincronizaba el entendimiento humano del sistema, y que esa fricción, aunque lenta, cumplía una función real.

En términos concretos, ese idioma compartido se materializa en artefactos técnicos y verificables: un archivo de invariantes arquitectónicas, un mapa de quién es dueño de cada módulo, un registro de decisiones de diseño. Cuando ese artefacto no existe o no se actualiza, un agente puede escribir un cambio perfectamente funcional que igual rompe una frontera que nadie documentó. Un ejemplo mínimo es un archivo CODEOWNERS que fuerza revisión humana en las fronteras críticas, exista o no un agente detrás del cambio:

# CODEOWNERS
# Fuerza revisión humana en las fronteras arquitectónicas
# aunque el cambio lo haya escrito un agente

/src/storage/          @equipo-datos
/src/auth/             @equipo-seguridad
/src/billing/          @equipo-pagos
CLAUDE.md              @arquitectura
ARCHITECTURE.md        @arquitectura

Este archivo no impide que un agente proponga el cambio: impide que se fusione sin que la persona dueña de esa frontera lo revise. Es la fricción que Ronacher describe, pero convertida en una regla explícita en vez de depender de que alguien la recuerde.

Cómo empezar: mitigar el riesgo hoy

La recomendación implícita del ensayo es documentar antes de delegar. Un archivo CLAUDE.md o ARCHITECTURE.md en la raíz del repositorio, con las invariantes del sistema escritas en texto plano, le da a cualquier agente (y a cualquier persona nueva) el contexto que antes solo vivía en la cabeza del equipo.

El segundo paso es automatizar la fricción que se perdió, en vez de lamentarla. Un script simple en el pipeline de CI puede bloquear un merge que toca una frontera sensible sin la aprobación explícita del equipo dueño:

#!/bin/bash
# boundary-check.sh: bloquea merges que tocan una frontera
# sin revision del equipo dueño correspondiente

CAMBIOS=$(git diff --name-only origin/main...HEAD)

if echo "$CAMBIOS" | grep -q "^src/storage/"; then
  if ! git log origin/main..HEAD --format="%b" | grep -q "Reviewed-by: equipo-datos"; then
    echo "Bloqueado: cambio en storage sin revision de @equipo-datos"
    exit 1
  fi
fi

echo "OK: fronteras respetadas"

Para confirmar que esta política está realmente activa en un repositorio de GitHub, y no solo documentada, se puede correr gh api repos/:owner/:repo/branches/main/protection y revisar que el campo required_pull_request_reviews.require_code_owner_reviews devuelva true. Si devuelve false, el CODEOWNERS existe pero no se está exigiendo en la práctica.

⚠️ Ojo: un cambio que compila, pasa los tests y trae una explicación generada por el propio agente no garantiza que respete las invariantes arquitectónicas del sistema. Esa garantía solo la da un proceso explícito, no la ausencia de errores visibles.
Cada desarrollador tiene un traductor incansable para su parte de la torre.

Impacto y análisis

La comparación de Ronacher tiene una vuelta de tuerca respecto a la historia bíblica: en Babel, la pérdida del idioma común detiene la construcción. En la ingeniería asistida por IA, la construcción puede continuar después de que el entendimiento compartido ya colapsó. La ausencia de una falla inmediata es lo que hace este fenómeno curioso y un poco desorientador: la torre no se cae, entonces nadie nota lo que se perdió.

El siguiente diagrama resume la diferencia entre los dos modelos de coordinación que describe el ensayo:

flowchart TD
    subgraph Antes["Antes: coordinacion con friccion"]
    D1["Desarrollador"] --> R1["Code review"]
    R1 --> T1["Entendimiento compartido"]
    T1 --> C1[("Codebase")]
    end
    subgraph Ahora["Ahora: agentes sin friccion"]
    D2["Desarrollador"] --> A2["Agente de IA"]
    A2 --> C2[("Codebase")]
    end

La tabla siguiente compara cómo cambia cada aspecto de la coordinación de equipo entre un modelo con fricción humana obligatoria y uno con agentes sin salvaguardas:
AspectoAntes de los agentesCon agentes sin salvaguardasCoordinación entre equiposFricción obligatoria: leer código ajeno, preguntar, esperar revisiónCada desarrollador resuelve su parte sin consultar a otrosEntendimiento compartidoSe sincroniza lentamente vía code review y conversaciónPuede no formarse nunca: el agente explica solo lo localVelocidad de cambioLimitada por la disponibilidad de las personasLimitada solo por cuántos agentes se puedan lanzar en paraleloSeñal de alerta tempranaBloqueo visible: el PR no avanza sin aprobaciónNinguna: los tests pasan, el build compila, todo parece funcionar
El riesgo que describe Ronacher no es que el software falle mañana. Es que la arquitectura que permitiría a los humanos razonar juntos sobre el sistema desaparezca mientras los cambios se siguen fusionando sin problema. El onboarding, la respuesta a incidentes y la revisión de seguridad dependen todos de que exista ese entendimiento compartido; cuando se erosiona, el costo se paga después, no en el momento del cambio.

Qué sigue

Ronacher no propone en el ensayo una solución técnica cerrada, y es consistente con su costumbre de escribir observaciones antes que recetas. Pero el problema que plantea ya empuja a la industria hacia prácticas más explícitas: archivos de contexto para agentes como CLAUDE.md o AGENTS.md, revisión arquitectónica obligatoria independiente de quién escribió el cambio, y herramientas de análisis estático que detecten violaciones de fronteras entre módulos antes del merge.

Es previsible que este tema vuelva a aparecer en su blog: la etiqueta "ai" ya acumula varias entradas relacionadas, y el propio autor cierra el ensayo dejando la pregunta abierta en vez de resuelta.

📖 Resumen en Telegram: Ver resumen

Probá vos: escribí hoy mismo un archivo ARCHITECTURE.md con las invariantes de tu sistema antes de dejar que un agente toque tu capa de almacenamiento.

Preguntas frecuentes

¿Quién es Armin Ronacher?

Es el creador de Flask, Jinja2 y Click, proyectos centrales del ecosistema Pallets en Python. Actualmente trabaja en Sentry y escribe con frecuencia sobre el impacto de los agentes de IA en la ingeniería de software.

¿Qué significa "vibe coding"?

Es el término informal para programar delegando buena parte de la implementación a un agente de IA, revisando el resultado más por su comportamiento observable que por una lectura línea a línea del código generado.

¿La Torre de Babel realmente se derrumbó en el texto bíblico?

No. Según Génesis 11:3-6, Dios no destruye la torre ni quita el conocimiento de construirla: confunde el idioma de los constructores, y la obra se detiene por falta de coordinación, no por un derrumbe físico.

¿Ronacher dice que los agentes de IA escriben peor código?

No. Su argumento es distinto: el código puede compilar y pasar los tests sin problema. El riesgo es que el entendimiento arquitectónico compartido entre las personas del equipo deje de formarse.

¿Cómo se puede mitigar este riesgo en un equipo real?

Con prácticas explícitas: archivos de invariantes documentadas, un CODEOWNERS que fuerce revisión humana en fronteras críticas, y revisión arquitectónica periódica que no dependa de si el cambio lo escribió una persona o un agente.

¿Dónde se puede leer el ensayo completo?

En el blog personal de Ronacher, lucumr.pocoo.org, publicado el 13 de julio de 2026 bajo licencia Creative Commons Attribution-NonCommercial 4.0 International.

Referencias

• The Tower Keeps Rising: ensayo original de Armin Ronacher, publicado el 13 de julio de 2026.- Tower of Babel: contexto histórico y bíblico del relato citado en el ensayo.- The Tower of Babel (Bruegel): sobre la pintura de Pieter Bruegel el Viejo que inspira la metáfora.- pallets/flask: repositorio del framework creado por Armin Ronacher.- CC BY-NC 4.0: licencia bajo la cual está publicado el ensayo original.

📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.