Una especificación precisa ya es código

Dima · junio de 2026

Durante décadas, una misma predicción ha reaparecido una y otra vez en el mundo de la ingeniería de software: el código fuente desaparecerá.

En los primeros años de la informática, se afirmaba que COBOL permitiría a los directivos empresariales desarrollar software directamente. Durante la década de 1980, los lenguajes de cuarta generación (4GL) prometían acabar con la necesidad de programadores profesionales. En los años noventa y dos mil, las herramientas CASE y UML ejecutable aseguraban que bastaría con dibujar diagramas para que el software se construyera automáticamente a partir de representaciones visuales.

Ninguna de estas promesas se cumplió.

Ahora estamos presenciando la versión más ambiciosa de esta misma predicción. Con la llegada de los grandes modelos de lenguaje (LLM) y los entornos de desarrollo basados en agentes, el discurso ha cambiado: ya no se afirma que los diagramas sustituirán al código, sino que lo harán las instrucciones escritas en lenguaje natural.

Algunas figuras destacadas de la industria sostienen que el inglés se ha convertido en el nuevo lenguaje de programación y que, en un futuro próximo, el código fuente será una reliquia histórica. Según esta visión, la inteligencia artificial generará el código como si fuera un lenguaje intermedio, lo compilará y lo ocultará a los seres humanos.

Este debate ocupó un lugar destacado en el Future of Software Development Retreat, celebrado en febrero de 2026. Sin embargo, a medida que avanza el año y aumenta la adopción de la inteligencia artificial, los repositorios de código siguen siendo fundamentales. Git continúa siendo la referencia compartida para almacenar, revisar y controlar las versiones del software.

Los ingenieros utilizan intensivamente la inteligencia artificial, pero la emplean para escribir, modificar, refactorizar y comprender más código, no para prescindir de él.

¿Por qué sucede esto?

La evolución histórica de la abstracción

Para comprender por qué el código persiste, primero debemos entender qué significa realmente programar.

Programar no consiste simplemente en escribir caracteres en un editor de texto. Es un proceso riguroso de formalización del pensamiento: transformar intenciones humanas, a menudo vagas y ambiguas, en un modelo de ejecución explícito y determinista.

Durante los últimos setenta años, la industria del software ha avanzado continuamente hacia niveles de abstracción más elevados.

Comenzamos conectando cables en paneles de control. Después llegaron el lenguaje ensamblador, los lenguajes estructurados como C y, posteriormente, los paradigmas orientados a objetos y funcionales, representados por tecnologías como Java, Python y TypeScript.

Cada avance permitió desarrollar software más legible, comprensible y portable.

Sin embargo, existe un patrón fundamental: aumentar el nivel de abstracción nunca ha eliminado el código; simplemente ha cambiado su forma.

Cuando pasamos del ensamblador a C, no dejamos de programar. Dejamos de preocuparnos directamente por los registros del procesador para concentrarnos en estructuras como bucles y funciones.

Cuando adoptamos frameworks modernos, dejamos de gestionar manualmente determinados aspectos de la memoria para centrarnos en la lógica de negocio y los modelos del dominio.

La inteligencia artificial generativa representa el siguiente paso lógico de esta evolución. Funciona como una interfaz flexible y sensible al contexto que se sitúa por encima de los lenguajes de programación existentes.

Pero interpretar la IA como una tecnología destinada a eliminar el código supone ignorar una de las restricciones fundamentales de cualquier sistema informático: la necesidad de precisión.

La barrera epistemológica: precisión frente a ambigüedad

El lenguaje humano es una herramienta extraordinaria para colaborar precisamente porque es flexible, ambiguo y dependiente del contexto.

Si le pido a un compañero que desarrolle un proceso de compra que calcule automáticamente los impuestos sobre las ventas, probablemente comprenderá el objetivo general. Utilizará sus conocimientos, preguntará qué jurisdicciones deben contemplarse y tendrá en cuenta los casos excepcionales que considere relevantes.

Los ordenadores, incluidos aquellos que utilizan redes neuronales, necesitan comportamientos definidos con precisión en los límites de ejecución.

No es una objeción nueva. Edsger Dijkstra la escribió hacia 1978 en «On the foolishness of “natural language programming”»: los símbolos formales no son una carga, sino lo que impide los disparates que el lenguaje natural deja pasar.

Cuando proporcionamos una instrucción ambigua a un modelo de lenguaje, este puede generar fragmentos de código sintácticamente correctos a partir de patrones probabilísticos aprendidos durante el entrenamiento.

Para crear un script independiente o una función auxiliar sencilla, este mecanismo suele funcionar muy bien.

El problema aparece cuando aumenta la complejidad del sistema. A medida que se acumulan los requisitos y sus interdependencias, también crece el número de situaciones que deben contemplarse.

Basta el ejemplo de los impuestos. «Calcula el IVA del pedido» parece una instrucción completa. Tres artículos de 0,35 € al 21 %:

from decimal import Decimal, ROUND_HALF_UP

def cents(x):
    return x.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

prices, rate = [Decimal("0.35")] * 3, Decimal("0.21")

per_line = sum(cents(p * rate) for p in prices)   # 0.21
on_total = cents(sum(prices) * rate)              # 0.22

Fig. 1 — Una frase, dos programas correctos. El mismo pedido, tres artículos de 0,35 € con un 21 % de impuesto, calculado en la página de las dos maneras. Redondeando cada línea salen 0,21 €; redondeando el total, 0,22 €. La instrucción no elegía.

Las dos son lecturas correctas de la frase, y difieren en un céntimo. La frase no decía si se redondea por línea o sobre el total, ni con qué regla de redondeo, y el programa no puede dejarlo sin decidir. Alguien lo decide: quien escribe el código, o el modelo en su lugar, sin avisar.

Para conseguir que una inteligencia artificial desarrolle correctamente un sistema empresarial complejo mediante instrucciones en lenguaje natural, habría que especificar, entre otras cosas:

Las reglas exactas de validación de los datos.
Las condiciones de carrera y los límites de concurrencia.
Los procedimientos específicos para gestionar errores y los estados alternativos.
Los requisitos normativos y los parámetros necesarios para garantizar su cumplimiento.

Cuando perfeccionamos las instrucciones hasta eliminar cualquier ambigüedad relevante y reducir la necesidad de que la IA adivine cómo debe comportarse el sistema, terminamos construyendo una especificación.

Y aquí reside el argumento central: una especificación precisa e inequívoca de un sistema informático cumple, en esencia, la misma función que el código fuente.

No importa que esté escrita en Python, en un dialecto de Markdown altamente estructurado o mediante un conjunto de afirmaciones lógicas estrictas. Si define de forma precisa el comportamiento que debe ejecutar una máquina, está desempeñando una función propia del código.

La abstracción puede cambiar el formato de la especificación, pero no elimina la necesidad de definir el comportamiento del sistema.

Los problemas simétricos de velocidad, mantenimiento y seguridad

Es indiscutible que la inteligencia artificial ha acelerado la producción de código.

Herramientas como GitHub Copilot, Windsurf y Cursor han pasado de ser experimentos prometedores a convertirse en componentes habituales de los entornos de desarrollo modernos.

En un experimento controlado, los desarrolladores que usaban Copilot completaron una tarea concreta, escribir un servidor HTTP en JavaScript, un 55,8 % más rápido que el grupo de control.

El dato contrario también existe. En otro ensayo, 16 desarrolladores con experiencia, trabajando en proyectos maduros de código abierto, tardaron un 19 % más cuando se les permitía usar IA, y aun así creían haber ido más rápido. La diferencia entre los dos resultados está en la tarea: una función nueva y aislada frente a un sistema maduro que hay que entender antes de tocar.

Escribir código rápidamente representa solo una pequeña parte del desafío que supone desarrollar software.

Existe una máxima conocida en ingeniería: el código se lee muchas más veces de las que se escribe.

El coste de comprender el código

Imaginemos que una inteligencia artificial genera 500 líneas de código en tres segundos a partir de una instrucción breve.

¿Quién es responsable de comprobar que esas 500 líneas son correctas?

El desarrollador debe revisar el resultado, comprender su funcionamiento y verificar que satisface los requisitos.

Aunque los modelos de IA son eficaces en muchas tareas de bajo nivel, pueden tener dificultades con decisiones arquitectónicas complejas y con el diseño global de sistemas.

Si los ingenieros empiezan a tratar el código generado como una caja negra que no necesitan inspeccionar, renuncian a una parte esencial de su capacidad para diagnosticar errores cuando el sistema falle en condiciones reales o aumente su escala.

Generar código más deprisa no elimina el trabajo de comprenderlo. Puede incluso trasladar el esfuerzo desde la escritura hacia la revisión, la depuración y el mantenimiento.

El dilema de la transparencia y la seguridad

Ocultar el código fuente detrás de una capa de generación mediante inteligencia artificial introduce riesgos importantes para la transparencia y la seguridad.

Los modelos pueden producir código con vulnerabilidades que no resultan evidentes a primera vista.

Si dejamos de mantener una base de código accesible, inspeccionable y controlada mediante versiones, perdemos una herramienta fundamental para auditar el software.

Esto dificulta detectar vulnerabilidades, comprobar el cumplimiento de las licencias y descubrir posibles inserciones de código malicioso.

El código fuente proporciona un registro explícito del comportamiento previsto del sistema y permite examinar los cambios que se introducen en él.

Aunque disponer de código fuente no garantiza por sí solo la seguridad, su accesibilidad facilita la revisión, la auditoría y la identificación de errores.

Por tanto, sustituir la transparencia del código por una capa opaca de generación automática supone un riesgo que no debe ignorarse.

Una arquitectura de colaboración entre humanos e inteligencia artificial

¿A qué conclusión nos lleva todo esto?

El código fuente no está desapareciendo, pero nuestra relación con él está cambiando de manera fundamental.

Estamos abandonando progresivamente una etapa en la que el trabajo del desarrollador consistía en gran medida en escribir instrucciones manualmente y entrando en otra en la que su función principal será diseñar arquitecturas, definir requisitos y revisar los resultados generados.

En lugar de eliminar el código, está surgiendo un modelo de colaboración en el que cada parte asume tareas diferentes.

El desarrollador define la arquitectura, establece las intenciones del sistema, determina los modelos del dominio y supervisa las decisiones importantes.

La inteligencia artificial actúa como un asistente capaz de realizar tareas repetitivas de forma continua: generar estructuras de código, escribir pruebas unitarias, proponer refactorizaciones y acelerar la implementación de funcionalidades.

En este modelo, el código fuente sigue desempeñando una función esencial.

Constituye el contrato formal, almacenado y revisado mediante un sistema de control de versiones, que conecta las intenciones humanas con una ejecución informática predecible.

La inteligencia artificial puede facilitar enormemente la traducción de esas intenciones a código. Sin embargo, mientras los sistemas necesiten comportamientos precisos, verificables y mantenibles, seguirá siendo necesario contar con una representación formal que permita definirlos y examinarlos.

La evolución de la programación no consiste en eliminar el código, sino en elevar el nivel de abstracción y cambiar la forma en que los seres humanos lo producen, lo comprenden y lo mantienen.