Artículos en profundidad sobre la tecnología que da forma al futuro.

Asistentes de código con IA: 5 mitos, probados

Los asistentes de código con IA aceleran escribir, no la calidad del software. Cinco mitos puestos a prueba frente al diseño y la verificación.

Un brazo robótico inunda el suelo de una fábrica con ladrillos brillantes que se acumulan en una única puerta estrecha de inspección.
La generación se volvió rápida. La inspección no, y el rendimiento lo marca la etapa más lenta.

Jonathan Blow, el diseñador detrás de Braid y The Witness, y un tipo lo bastante terco como para pasar una década creando su propio lenguaje de programación, planteó hace poco una pregunta que debería escocer a todo proveedor que venda asistentes de código con IA: si la IA ya resolvió la programación, ¿por qué mi software sigue igual? Los mismos cuelgues. Las mismas actualizaciones infladas. Las mismas quejas de hace diez años sobre apps que devoran RAM mientras hacen menos que las herramientas que reemplazaron. La respuesta habitual, espera seis meses, no llega a cubrirlo, y no creo que Blow esté equivocado al tocar esa herida.

Esta es mi postura, tras años construyendo sistemas de ML y luego viendo cómo estas herramientas llegaban a equipos reales: los asistentes de código con IA son hoy realmente buenos, y realmente no han movido la aguja en el software que tú y yo usamos a diario. Ambas cosas son ciertas a la vez, y lo son porque las herramientas nunca apuntaron al verdadero cuello de botella. La forma más clara de verlo es tomar las cinco creencias que más escucho y probar cada una.

Mito 1: escribir código es el cuello de botella del desarrollo de software

La premisa se escribe sola: programar es producir código, así que una máquina que produce código diez veces más rápido hace el software diez veces más rápido. Es un silogismo ordenado con un fallo: nadie trabaja realmente así. Hay una vieja regla empírica, popularizada por Clean Code, según la cual los desarrolladores dedican bastante más de diez veces el tiempo a leer código que a escribirlo. Esa proporción es anterior a los LLM en quince años, pero cualquier análisis serio de cómo se gastan las horas de ingeniería llega al mismo lugar: entender el sistema existente, coordinarse con otras personas, esperar decisiones. Teclear es un error de redondeo.

Lo notas en tu propia semana. El autocompletado ahorra minutos reales (no lo cambiaría por nada), pero mis días difíciles nunca fueron difíciles porque no pudiera teclear lo bastante rápido. Fueron difíciles porque el servicio de pagos tenía un invariante que nadie escribió, o porque tres equipos no se ponían de acuerdo sobre lo que debía prometer la API. Acelerar la única etapa que no era lenta casi no afecta al rendimiento total. Una fábrica que estampa piezas más rápido de lo que su línea de inspección puede despachar no produce más: produce una pila más grande de piezas.

Hay un lugar donde teclear sí es de verdad el cuello de botella: el trabajo en greenfield, sin un sistema existente que respetar. Boilerplate, prototipos, scripts desechables, la primera versión de cualquier cosa. Justo por eso las demos parecen magia: las demos son todo greenfield, todo el tiempo. La ingeniería en producción es casi por completo brownfield, y el trabajo brownfield es trabajo de lectura.

Mito 2: el código generado por IA llega verificado

El flujo optimista va así: describes la tarea, el modelo escribe el código, pasan los tests, se hace merge. El fallo está en el paso del medio. Que los tests pasen solo te dice que los tests que se te ocurrió escribir concuerdan con el código que el modelo se le ocurrió escribir. Ambos pueden estar equivocados en la misma dirección, y con la salida de los LLM a menudo lo están: el modelo produce código fluido, idiomático y seguro de sí mismo, y esa fluidez es justo lo que desarma la revisión.

Aquí tienes un ejemplo pequeño que he visto en la práctica, en esencia si no en la forma exacta. Pide un planificador de tareas mensuales y obtendrás algo como esto:

from datetime import datetime
def next_monthly_run(day: int, hour: int = 9) -> datetime:
"""Next run time for a job that fires monthly on `day`."""
now = datetime.now()
candidate = now.replace(day=day, hour=hour, minute=0, second=0, microsecond=0)
if candidate <= now:
# Roll forward one month
month = now.month % 12 + 1
year = now.year + (1 if now.month == 12 else 0)
candidate = candidate.replace(year=year, month=month)
return candidate

Léelo como leerías el pull request de un compañero. Es idiomático. Maneja el cambio de año. Hasta el docstring es correcto. Ahora ejecútalo el 15 de abril con day=31: now.replace(day=31) lanza ValueError, porque abril no tiene día 31. La función falla justo en la petición de planificación más común (fin de mes) y solo en los meses cortos, así que puede estar en producción pareciendo sano durante semanas antes de que alguien lo note. Un test que recorra un año completo de valores de now lo detecta en segundos. Un revisor humano atento lo detecta quizá la mitad de las veces. Esa brecha es el problema de la verificación en miniatura.

Por eso insisto en que, en un flujo muy cargado de IA, la elección entre comprobaciones de comprensión y tests no es académica: es el partido entero. Leer código que no escribiste ya es más difícil que escribirlo. Leer código que ningún humano escribió, al volumen que producen estas herramientas, invierte por completo la economía de la revisión. Los equipos con los que hablo ya no escasean de código. Escasean de personas que entiendan lo que hace el código y estén dispuestas a firmarlo con su nombre.

Una lupa revela una grieta capilar que cruza una losa de mármol pulido.
El código plausible falla como falla el mármol: por una grieta que solo ves si miras.

Mito 3: código más barato significa diseño de software barato

Una creencia más sutil: si el código es casi gratis, la arquitectura importa menos, porque siempre podemos reescribir. ¿Mala abstracción? Regénerala. ¿Modelo de datos equivocado? Regenera también eso. He oído a ingenieros senior decirlo muy en serio, y confunde el coste de cambiar texto con el coste de cambiar decisiones.

La parte difícil del software nunca fue el código. Consiste en decidir qué merece la pena construir, modelar un dominio humano caótico en algo que una máquina pueda ejecutar, y tomar apuestas arquitectónicas que no se derrumben cuando cambian los requisitos, y siempre cambian. Son problemas de intención y de valores, no de completar patrones. Un modelo entrenado con el corpus del software existente puede decirte cómo suelen ser los sistemas parecidos al tuyo. No puede decirte cómo debería ser el tuyo, porque esa respuesta vive en tus usuarios, tus restricciones y el apetito de riesgo de tu organización. En este frente prácticamente no hemos avanzado, y sostengo que no es una brecha de capacidad de la que se pueda salir escalando. Es un desajuste de categoría.

Las reescrituras tampoco son gratis. La mayor parte del dinero de ingeniería se gasta cambiando sistemas que ya existen, y cambiar un sistema exige primero hacer ingeniería inversa de la intención incrustada en él: los invariantes que nadie documentó, el caso límite que resulta ser crucial para un cliente importante. El modelo no conoce esa intención. Tampoco, a menudo, el equipo. Esta es la brecha entre especificación e implementación, donde viven de verdad los bugs, y generar más implementación la amplía, a menos que alguien sostenga bien la especificación.

Fred Brooks tenía un término para lo que hace coherente al software: la integridad conceptual, la sensación de que una sola mente, o unas pocas mentes alineadas, tomaron las decisiones. La generación fluida de código no nos acerca a eso. Si acaso, abarata mil microdecisiones desalineadas, y así acabas con sistemas que parecen diseñados y se sienten ensamblados.

Mito 4: que el software no cambie demuestra que la IA para programar fracasó

Ahora el contrapunto, porque el planteamiento de Blow tampoco es infalible. Si miras más allá del software comercial de masas, las cosas sí se están moviendo. La escena indie ha producido juegos de estrategia con motores propios, hechos por equipos pequeños, que hace diez años habrían necesitado la plantilla de Blizzard. Más llamativo me parece el auge silencioso del software personal: gente que construye sus propios clientes de correo, apps de calendario, rastreadores de finanzas y frontends de git, moldeados exactamente según cómo piensan. Estas herramientas son toscas y nunca sobrevivirían a enviarse a diez mil desconocidos. Pero existen, se usan a diario y simplemente no era rentable construirlas antes.

Incluso las instituciones están cambiando de formas que la métrica principal no capta. Conozco organizaciones cuyo plan de modernización es, en esencia: exponer el sistema legado mediante APIs decentes y dejar que el personal construya sus propios endpoints e interfaces encima con una herramienta de programación agéntica. Eso no es «mi software sigue igual». Es software que se disuelve en algo más personal, invisible si solo miras las listas de la tienda de apps.

La razón más profunda por la que la observación de Blow parece cierta, sin embargo, es organizativa más que técnica. El software comercial está moldeado por lo que las empresas optimizan (engagement, lock-in, ritmo de lanzamientos, coste de soporte), y la IA te da más de lo que ya quieres, más rápido. No cambia lo que quieres. Una empresa que lanzó software inflado porque la hinchazón no aparecía en su hoja de costes ahora lanzará software inflado con un ciclo de desarrollo más corto. El listón de calidad para software que llega a miles de usuarios lo fijan los incentivos, la disciplina de testing y el criterio, ninguno de los cuales es una salida de modelo.

También hay un argumento de simple retraso. La programación con IA realmente fiable tiene quizá un año; el periodo anterior fue inestable, y antes de eso era un juguete. Los productos tardan años en concebirse, construirse y enviarse. Juzgar hoy el efecto de estas herramientas en el software publicado es como juzgar un arado nuevo por la cosecha de un mes después de inventarlo.

Mito 5: el próximo modelo cerrará la brecha

La versión más fuerte del argumento optimista: cada objeción anterior describe los modelos actuales, y los modelos actuales son los peores que usaremos jamás. En parte es cierto. Las ventanas de contexto crecerán, las APIs alucinadas se reducirán, los agentes mejorarán ejecutando sus propios tests. Esperaría avances reales, sobre todo en tareas bien especificadas.

Pero fíjate en qué cuellos de botella son problemas de capacidad y cuáles no. La verificación se vuelve más fácil a medida que los modelos son más fiables, y eso es capacidad. Decidir qué merece la pena construir, mantener la integridad conceptual, cambiar lo que una organización optimiza: nada de eso aparece en ninguna hoja de ruta de modelos, porque no son problemas de modelos. Y ten cuidado al usar el progreso en benchmarks como evidencia: los benchmarks no capturan la mayor parte de lo que es el trabajo real, y el trabajo real es justo el tipo subespecificado y cargado de intención.

Así que aquí va mi apuesta, por escrito: las herramientas mejorarán muchísimo para los constructores individuales y los equipos pequeños con buen criterio, y el software de masas mejorará marginalmente, si es que mejora, porque la restricción ahí nunca fue el código. Si suena pesimista, no lo es. Significa que la palanca está en tus manos y en tu organigrama, no en la próxima versión de un laboratorio.

Un jardinero poda un bonsái en un banco de trabajo iluminado por el sol, con herramientas de mano.
La calidad del software sigue siendo un problema de cuidado, no de producción.

Qué mejora de verdad la calidad del software

Si generar es barato y verificar es caro, la respuesta racional es redirigir la inversión. Concretamente:

  • Trata los tests y los tipos como infraestructura de producción. Los tests basados en propiedades, las comprobaciones de invariantes y un CI rápido son lo que convierte una generación barata en una generación barata y correcta. Presupuéntalos como presupuestas el cómputo.
  • Escribe la especificación antes que el prompt. La especificación es ahora el artefacto de mayor palanca que produce un equipo, porque es lo que el modelo no puede aportar y lo que los revisores contrastan.
  • Usa la IA donde es realmente fuerte: prototipos greenfield, migraciones, boilerplate, herramientas personales, explorar rápidamente un espacio de diseño. Desconfía de ella en rutas legadas críticas donde la intención no está documentada.
  • Protege el tiempo de diseño. Cuando la velocidad de generación se triplica, la presión es llenar la hoja de ruta tres veces. Resístete. Decidir es el trabajo.

El cuello de botella nunca fue teclear. Siempre fue decidir y demostrar.

La pregunta de Blow tiene respuesta, y es esperanzadora si la lees bien. El software parece igual porque su calidad siempre estuvo condicionada por decidir, verificar y el cuidado. Los asistentes de código con IA, con toda su utilidad real, aceleran la parte que nunca fue lenta. Eso significa que las herramientas para mejorar el software son las mismas de siempre: criterio, especificación y la disciplina de demostrar las cosas. Los modelos solo hicieron imposible seguir fingiendo lo contrario.