¿Recuerdas tu primera vez?

Hay momentos en los que descubres algo que cambia tu manera de ver las cosas. No necesariamente porque sea perfecto, ni porque lo entiendas por completo desde el primer momento, sino porque, de repente, te das cuenta de que algo que creías lejano, complicado o reservado para unos cuantos, ahora está a tu alcance…., ah, y no, no me refiero al despertar sexual que muchos vivimos en algún momento de nuestras vidas.

Para mí, uno de esos momentos llegó cuando descubrí que podía pedirle a una inteligencia artificial que desarrollara software por mí.

Y no, no fue precisamente como lo imaginaba.

El primer encuentro: ¿de verdad puede hacer eso?

Todo comenzó cuando un compañero del trabajo me habló de una herramienta de Google llamada Antigravity. Me contó un poco de lo que podía hacer y, como buen informático al que le hablan de algo nuevo, llegué a casa con la curiosidad a tope.

La descargué, la instalé en mi computadora personal y empecé a explorarla. Abrí sus apartados, revisé sus opciones e intenté entender cómo funcionaba aquello. Revisé los modelos que podía usar, aprendí lo suficiente sobre la manera de interactuar con la herramienta y decidí hacer una prueba rápida.

Quería algo sencillo: una aplicación tipo control de gastos, con datos almacenados localmente y sin complicarme con .NET, bases de datos ni arquitecturas elaboradas. Puro HTML, JavaScript y CSS.

Así que describí lo que quería y le di la indicación de comenzar.

Entonces ocurrió algo que, aunque hoy me parece cada vez más habitual, en aquel momento me dejó completamente sorprendido.

Antigravity empezó a generar la estructura, los archivos, a escribir código y a mostrarme información sobre las acciones que iba realizando. Yo observaba la pantalla con una mezcla de curiosidad y escepticismo. Veía cómo avanzaba, pero una parte de mí seguía pensando: «Está bien, pero vamos a ver qué termina haciendo».

Hasta que llegó el mensaje de que había terminado.

Fui a la carpeta donde había guardado el proyecto, busqué el archivo index.html y lo abrí en el navegador. Y ahí estaba. Una aplicación que hacía lo que le había pedido.

¿Era una maravilla del desarrollo de software? No. ¿Estaba perfectamente diseñada? Tampoco. ¿Había entendido todos los detalles que tenía en la cabeza? Ni de lejos.

Pero funcionaba. Y, para ser justos, funcionaba hasta donde mi pobre y raquítico prompt le había permitido entender lo que yo quería. Me quedé mirando aquella aplicación con auténtico asombro.

Una herramienta de software, apoyada en modelos de inteligencia artificial, había creado otra herramienta de software prácticamente sin que yo tuviera que escribir una sola línea de código.

Yo había descrito una necesidad y había observado cómo se convertía en archivos, en código que podía ejecutar en mi computadora.

En ese momento entendí, aunque todavía no sabía explicarlo bien, que estaba ante algo diferente. No era simplemente un autocompletado de código de toda la vida, ni una herramienta que me sugiriera cómo resolver un problema. Era otra forma de trabajar.

Y apenas estaba empezando.

El entusiasmo del principiante y el regreso del ingeniero

Después aprendí que lo que había hecho aquella primera noche tenía nombre: vibe coding.

Había descrito una idea, había dejado que la inteligencia artificial generara el código y había comprobado el resultado sin detenerme demasiado a definir una arquitectura, documentar requisitos o establecer criterios rigurosos de calidad.

Lo acepto: fue mi primera aplicación desarrollada mediante vibe coding. Y fue una experiencia fantástica (aunque no tanto como el despertar aquél que mencioné al inicio).

Pero soy ingeniero. Me dedico al desarrollo de software, al análisis de sistemas y a la administración de tecnologías. Sé que una aplicación que funciona en una prueba rápida no es necesariamente una aplicación que esté preparada para utilizarse en un entorno real.

Así que, después de aquella primera experiencia, hice lo que probablemente habría hecho desde el principio si hubiera abordado el proyecto como un desarrollo profesional.

La segunda vez: ahora sí, vamos a trabajar

Volví a Antigravity, pero esta vez con un propósito muy diferente.

Esta vez no quería experimentar simplemente con una herramienta. Quería comprobar hasta dónde podía llegar utilizándola para desarrollar un sistema real para mi trabajo.

Ya no se trataba de pedirle una aplicación sencilla y esperar a ver qué ocurría. Volví a mis documentos de análisis. Definí los requerimientos, las vistas, las tablas, la base de datos y el stack tecnológico. Organicé las ideas, establecí las reglas y preparé un documento técnico que describía qué debía construir el sistema y cómo esperaba que se implementara.

Al término del proceso de análisis y documentación, tenía el documento técnico, con una idea mucho más clara de lo que necesitaba y una serie de condiciones que debía respetar. Le proporcioné esta documentación a Antigravity.

No quería que inventara una arquitectura sobre la marcha ni que eligiera las tecnologías que le parecieran más cómodas. Necesitaba un sistema desarrollado con .NET Core, utilizando MVC, con sus modelos, controladores y vistas; con un diseño institucional, reglas de seguridad y una estructura coherente con los estándares que utilizamos en el trabajo.

Para ello, incorporé instrucciones y una skill que ayudaran a orientar la implementación hacia esas decisiones. Revisamos juntos el documento, afinamos indicaciones y corregimos los aspectos que todavía no estaban suficientemente definidos. En aquel momento aún no conocía el concepto de Spec-Driven Development (SDD), algo que descubriría días después y que me ayudaría a entender mejor cómo estructurar este tipo de trabajo.

Cuando consideré que teníamos una base suficientemente sólida, llegó el momento de dar la indicación:

Empieza a programar.

Y volví a sentir aquella sorpresa de la primera noche, pero multiplicada. Vi cómo se creaba la carpeta del proyecto, cómo aparecían los controladores, los modelos y las vistas, y cómo se iban integrando funcionalidades que, trabajando de la manera tradicional, me habrían llevado horas o incluso días hacer.

No estaba observando fragmentos de código aislados. Estaba viendo cómo tomaba forma una aplicación con una estructura que yo mismo había definido y unas tecnologías que había elegido deliberadamente.

Me quedé pegado al monitor durante todo el proceso, siguiendo los avances, revisando lo que aparecía y tratando de asimilar la velocidad a la que se estaba construyendo el sistema. En un par de horas, aproximadamente el 60% del desarrollo inicial estaba hecho.

¿Estaba listo para entrar en producción? Por supuesto que no.

Y esta distinción es importante.

Una cosa es generar una gran cantidad de código y otra muy distinta es tener un sistema probado, seguro, consistente y preparado para que sus usuarios trabajen con él. Todavía había funcionalidades que ajustar, errores que detectar, comportamientos que corregir y decisiones que revisar.

Pero la base estaba ahí. Y se había construido a una velocidad que, hasta entonces, me habría parecido difícil de imaginar.

Veinte días frente a dos o tres meses

El sistema terminó tomando alrededor de veinte días de trabajo para llegar a una versión funcional que pudiera presentar.

Veinte días.

Mi estimación inicial, desarrollándolo de la manera tradicional, habría sido de dos o tres meses como mínimo.

No pretendo presentar esta comparación como una regla universal. Cada proyecto es diferente, y los resultados dependen de la complejidad, los requisitos, la calidad esperada y el trabajo de revisión necesario. Pero, en mi caso, la diferencia fue lo suficientemente grande como para cambiar mi perspectiva sobre el desarrollo de software.

La inteligencia artificial no había eliminado la necesidad de analizar, decidir, probar o corregir. Había cambiado radicalmente la velocidad con la que podía transformar mis decisiones en una implementación concreta.

Y eso tiene un valor enorme porque, cuando trabajas en desarrollo, sabes que escribir código es solo una parte del trabajo. Antes hay que entender el problema, identificar las necesidades, diseñar una solución y tomar decisiones que condicionarán todo lo que venga después.

Y después hay que comprobar que lo construido realmente resuelve el problema. La IA puede ayudarte en muchas de esas etapas, pero no convierte automáticamente una descripción ambigua en un sistema impecable.

De hecho, mi primera aplicación me enseñó algo muy sencillo: si das instrucciones pobres, puedes obtener un resultado funcional, pero limitado. Y mi segunda experiencia me demostró que una mejor preparación, acompañada de indicaciones claras y una revisión constante, puede producir resultados mucho más útiles.

La diferencia no estaba únicamente en la herramienta. También estaba en cómo yo había aprendido a utilizarla.

¿El mérito es mío o de la inteligencia artificial?

Esta es una pregunta que me he hecho más de una vez. Después de todo, yo no escribí manualmente buena parte del código que terminó formando el sistema. Fue la inteligencia artificial la que generó archivos, implementó funciones y propuso soluciones.

Entonces, ¿qué parte del mérito me corresponde? Creo que la respuesta está en entender que mi trabajo no desapareció. Cambió de lugar.

Yo hice el análisis, definí los requerimientos, seleccioné las tecnologías, establecí la estructura, preparé las instrucciones y fui tomando decisiones durante el desarrollo. También tuve que revisar los resultados, detectar comportamientos incorrectos, solicitar correcciones y comprobar que las funcionalidades respondieran a lo que necesitaba.

La IA se encargó de buena parte de la implementación que, de otra manera, yo habría tenido que escribir línea por línea.

Y sí, eso significa que ahora puedo dedicar menos tiempo a determinadas tareas de programación y más a definir qué hay que construir, cómo debe funcionar y cómo comprobar que lo hace correctamente. Pero sería un error creer que, porque una IA genera código, ya no necesitamos entenderlo.

Todavía tengo mucho que aprender. Necesito dedicar más tiempo a revisar el código generado, comprender las decisiones que hay detrás de él y asegurarme de que la solución sea mantenible y segura. No basta con que la aplicación funcione cuando la probamos; también hay que entender qué sucede cuando algo falla, cuando cambian los requisitos o cuando aparecen situaciones que no habíamos previsto.

La productividad sin criterio puede llevarnos a construir más rápido algo que no deberíamos haber construido así. Por eso, mi objetivo no es convertirme en alguien que escribe menos código sin saber qué está pasando. Quiero convertirme en un ingeniero capaz de aprovechar estas herramientas, dirigirlas correctamente y evaluar con criterio el trabajo que producen.

No quiero dejar de entender el software que desarrollo. Quiero tener la capacidad de desarrollar más y mejores soluciones sin que la escritura manual de cada línea sea necesariamente el centro de mi trabajo.

Mi compañero de código

Este ha sido mi primer año trabajando con inteligencia artificial de esta manera, integrándola de forma activa en el desarrollo de software. Y, sinceramente, creo que nunca lo olvidaré.

Todavía recuerdo aquella primera aplicación de control de gastos, la carpeta con los archivos generados y el momento en que abrí el index.html en el navegador. Era algo sencillo, incluso rudimentario, pero representaba una posibilidad que hasta entonces no había experimentado de esa manera.

Después llegó el desarrollo del sistema real, la documentación técnica, las instrucciones, las herramientas, las skills y el descubrimiento de nuevas metodologías para trabajar con agentes de programación.

He pasado de experimentar con una idea sencilla a utilizar estas herramientas para afrontar proyectos con requisitos y expectativas reales. Y apenas estoy empezando a comprender todo lo que puedo hacer con ellas.

Quiero aprender más, mejorar mi manera de trabajar, revisar mejor el código y conocer las metodologías que permiten desarrollar sistemas de forma más ordenada y profesional. Quiero entender mejor esa especie de magia que ocurre cuando un agente convierte una descripción en una estructura de archivos, clases, funciones y vistas.

Y también quiero aprender a colaborar mejor con ese compañero de código que, aunque no sustituye mi criterio ni asume mi responsabilidad, puede ayudarme a llegar mucho más lejos.

Porque la inteligencia artificial no tiene que ser una competencia entre el ser humano y la máquina. Al menos, en mi experiencia, ha sido una oportunidad para combinar lo que sé hacer con capacidades que antes no tenía a mi alcance de esa manera.

Y quiero aprovecharla.

¿Recuerdas tu primera vez?

Quizá tú también recuerdes el primer momento en que utilizaste una herramienta de inteligencia artificial y te quedaste sorprendido por lo que era capaz de hacer.

Tal vez fue cuando respondió una pregunta que llevabas tiempo intentando resolver, cuando generó una imagen a partir de una descripción, cuando te ayudó a escribir algo que no sabías cómo empezar o cuando creó un programa que nunca habrías imaginado terminar tan rápido.

Puede que, como me ocurrió a mí, tu primera reacción fuera una mezcla de incredulidad, entusiasmo y curiosidad. Con el tiempo, esa sorpresa se vuelve más cotidiana. Aprendes a formular mejores instrucciones, descubres las limitaciones, identificas los errores y dejas de maravillarte cada vez que la herramienta produce un resultado.

Empiezas a utilizarla como parte de tu trabajo.

Pero no quiero perder de vista aquella primera sensación. Quiero recordar lo que sentí al abrir mi primera aplicación y descubrir que realmente funcionaba. Quiero conservar esa curiosidad, seguir aprendiendo y no dar por sentado lo que hoy estas herramientas hacen posible.

Porque, más allá de la velocidad, los modelos o las nuevas tecnologías que aparezcan, lo verdaderamente importante será lo que seamos capaces de aprender y construir con ellas.

Ahora te toca a ti: ¿recuerdas tu primera vez con la inteligencia artificial?

¿Cuál fue esa experiencia que te hizo pensar: «Un momento… ¿de verdad puede hacer esto»?

Me encantará leerte en los comentarios.


Este artículo forma parte de mi experiencia personal aprendiendo a trabajar con inteligencia artificial, agentes de programación y nuevas formas de desarrollar software. No pretendo tener todas las respuestas; precisamente, este espacio nace para seguir explorando, aprendiendo y compartiendo lo que vaya descubriendo.

Un comentario

  1. Pingback:De un documento técnico a una aplicación: mi experiencia con SDD usando Kiro - TecnImagIA

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *