Programar con Inteligencia Artificial: ella escribe, yo pienso

La Inteligencia Artificial escribe código más deprisa que yo. Mucho más. Y no tiene ningún sentido competir con eso.

Lo que sí tiene sentido es preguntarse qué hago yo con el tiempo que me ahorra. Mi respuesta es sencilla: lo uso para pensar: para revisar lo que escribe, para centrarme en la arquitectura del software y para formar a juniors. La arquitectura es justo la parte que la Inteligencia Artificial no hace bien y la que más importa cuando un proyecto tiene que vivir más de dos semanas.

Llevo TREINTA años desarrollando aplicaciones. He visto llegar y pasar muchas modas que iban a acabar con los programadores. Esta es la primera que de verdad cambia cómo trabajo, pero no en el sentido que se suele contar.

De Copilot a Claude Code: lo que para mí es la perfección

Llevo usando asistentes y agentes de Inteligencia Artificial desde GitHub Copilot, que fue con el que empecé (lo conté en cómo la Inteligencia Artificial me devolvió la ilusión por programar). Y Copilot hacía justo lo que para mí es la perfección: intuir. Para mí era magia. Intuía lo que yo iba a teclear, el código que iba a escribir, y lo autocompletaba antes de que yo terminara de pensarlo.

Eso es lo que, para mí, tiene que hacer la Inteligencia Artificial: ayudarme a escribir más rápido. O, como hacen ahora los agentes, escribir ella el código, pero escribirlo de forma que yo pueda leerlo y entenderlo después, siguiendo las normas que yo marco. Esas normas son las que he metido en mi skill senior-mindset.

Hoy, como casi todo el mundo, uso sobre todo Claude Code. A veces Codex y, según el caso, también bastantes herramientas libres, como las que repasé en la review de OpenCode y sus competidores. La herramienta cambia; la forma de trabajar, no.

La visión que se lleva ahora (y por qué no es la mía)

Lo que se lleva ahora es pedirle a la Inteligencia Artificial que haga algo, mirar si funciona y, si funciona, seguir adelante. Sin leer lo que ha escrito. Si falla, le pegas el error y que lo arregle ella. Y así, prompt a prompt, hasta que el proyecto es un montón de código que nadie ha leído entero, ni siquiera quien lo “programó”.

Ahora parece que la Inteligencia Artificial está para sacar más, más y más código. Código a granel, lo que en inglés ya llaman slop: montañas de líneas que nadie ha pedido y que nadie va a leer. Siendo realistas, es puñetera mierda. Y esa no es mi forma de pensar. De la versión más extrema de esto, el vibe coding, ya hablé en la realidad de programar con Inteligencia Artificial.

Para un prototipo de fin de semana, me parece estupendo. Para algo que va a estar en producción, que va a tocar datos de gente o que alguien va a tener que mantener dentro de un año, me parece una bomba de relojería. El código que nadie entiende no es un activo, es una deuda. Y con la Inteligencia Artificial esa deuda se acumula más rápido que nunca, porque nunca se había podido escribir tanto código sin entenderlo.

Mi visión de cómo programar con Inteligencia Artificial es bastante distinta. Yo sigo leyendo código y sigo escribiendo código. No delego el entender lo que hay en mi proyecto, solo delego el teclear.

La premisa: ella escribe, yo pienso

Cuando escribía todo el código a mano, la mayor parte del tiempo se me iba en teclear: la sintaxis, el código de relleno, las pruebas repetitivas. Pensar en el diseño quedaba para los huecos.

Con la Inteligencia Artificial, eso se da la vuelta. El tiempo que antes se iba en escribir, ahora lo dedico a tres cosas:

Revisar lo que escribe. Leerlo de verdad, entenderlo y decidir si se queda, se cambia o se tira.
La arquitectura. Cómo encajan las piezas, qué decisiones se toman y por qué, qué va a pasar cuando el proyecto crezca.
Formar a juniors. Enseñar a los que vienen detrás lo que la Inteligencia Artificial no les va a enseñar: a leer código, a dudar de él y a decidir. Te cuento por qué en sin juniors hoy no hay seniors mañana.

En la práctica, mi flujo se parece más al de un jefe de equipo que al de un programador solitario. Antes de que Claude escriba nada, pienso yo qué hay que hacer y cómo debería encajar, y lo dejo escrito en una spec (es el primer paso que obliga a dar mi skill senior-mindset). Mientras Claude implementa una tarea, yo leo la anterior o pienso la siguiente. Y cuando termina, reviso el resultado con calma antes de dar el visto bueno.

No es más lento de lo que parece. La Inteligencia Artificial escribe en minutos lo que a mí me costaría mucho más tiempo, así que aunque dedique un buen rato a leerlo y entenderlo, sigo saliendo ganando. Y lo que gano no es solo tiempo: es saber exactamente qué hay en mi proyecto.

Revisar no es echar un vistazo

Revisar el código que escribe la Inteligencia Artificial no es mirar si compila y si pasan los tests. Es leerlo como leerías el de un compañero nuevo: con cariño, pero sin fiarte.

Cuando reviso, hay cosas que busco siempre:

Código duplicado. La Inteligencia Artificial no se acuerda de lo que ya existe, así que escribe otra vez lo que ya estaba.
Nombres que no dicen nada. data2, handleStuff, tmp. Si no entiendo qué hace por el nombre, se cambia.
Seguridad. Consultas montadas concatenando texto, secretos en el código, entradas sin validar.
Complejidad de más. Abstracciones que nadie ha pedido para problemas que no existen.
Lo que no hace. Casos límite que no contempla, errores que se traga sin avisar.

Y hay una regla que no me salto nunca: si no entiendo un trozo de código, no entra. Da igual que funcione.

Para revisar bien, el código tiene que estar escrito para que lo lea un humano. Si los nombres no explican lo que hacen, si las funciones hacen cinco cosas a la vez o si nadie sabe por qué se eligió esa librería, revisar se convierte en arqueología. Por eso, para mí, la legibilidad no es un capricho estético: es lo que hace posible revisar.

La arquitectura es lo que no se delega

La Inteligencia Artificial escribe muy bien funciones sueltas. Donde flojea es en la visión de conjunto (ya conté en lo que no te cuentan sobre los agentes de Inteligencia Artificial que de inteligentes tienen poco): no se acuerda de lo que hizo ayer, no sabe que ya existe una función que hace lo mismo y no tiene ningún interés en que el proyecto siga siendo mantenible dentro de un año.

Esa parte la pongo yo. Las decisiones de arquitectura las tomo yo, y quedan escritas para que la siguiente sesión (mía o de la Inteligencia Artificial) no tenga que adivinarlas. En mi caso, como ADRs: un documento corto por decisión con su motivo, que es lo que genera senior-mindset cada vez que se decide algo que afecta a todo el proyecto.

Elegir la base de datos, decidir dónde se despliega, cómo se separan los módulos o qué parte del sistema tiene que ser asíncrona son decisiones que van a condicionar el proyecto durante años. La Inteligencia Artificial te va a proponer algo razonable, y muchas veces acertará. Pero no conoce el contexto como yo: el presupuesto, quién va a mantenerlo, qué crecimiento se espera o qué sé hacer bien y qué no. Esas decisiones las tomo yo, la Inteligencia Artificial me ayuda a pensarlas. Es una diferencia pequeña en la frase y enorme en el resultado.

Cómo se traduce esto en mi skill senior-mindset

Esta forma de trabajar es la que está detrás de senior-mindset, mi skill para que Claude Code programe como un senior. Casi todas sus normas están pensadas para el humano que va a leer el código después:

Spec antes que código, para que yo apruebe el qué y el por qué antes de que se escriba nada.
ADRs, para que cada decisión de arquitectura quede escrita con su motivo.
Un inventario de lo que ya existe, para no reinventar funciones que ya están.
Código para humanos y en inglés, con nombres que se explican solos.

No es una skill para dejar que Claude programe solo mientras yo miro. Es una skill para que lo que escribe sea fácil de revisar, que es lo que yo hago con mi tiempo.

Si en tu empresa queréis trabajar así con asistentes de código, puedo ayudarte.

El otro uso de ese tiempo: formar juniors

La tercera de esas cosas merece su propio apartado, porque para mí es la más importante: formar a juniors. Son los grandes olvidados de todo esto. Las empresas contratan menos juniors porque “la Inteligencia Artificial ya hace ese trabajo”, y los seniors que quedan dedican las horas que ganan a producir más código, no a enseñar.

Es un error enorme. Los seniors que hoy dirigen a la Inteligencia Artificial fueron juniors hace unos años, y alguien les enseñó. Si ahora no formamos juniors, dentro de unos años no habrá seniors capaces de revisar lo que escribe la máquina y de tomar las decisiones de arquitectura que ella no sabe tomar. De eso hablo con calma en sin juniors hoy no hay seniors mañana.

Lo que gano (y lo que no)

Lo que gano es tranquilidad. Sé qué hay en mis proyectos, por qué está ahí y cómo cambiarlo. Cuando algo falla, no tengo que preguntarle a la Inteligencia Artificial qué demonios hizo hace tres semanas: lo sé, porque lo leí y porque quedó escrito. Y de paso sigo aprendiendo, porque leer código bien escrito (y mal escrito) enseña muchísimo.

Lo que no gano es velocidad pura. Alguien que acepta todo lo que le escribe la Inteligencia Artificial sin leerlo va más rápido que yo los primeros días. La diferencia aparece a las pocas semanas, cuando su proyecto empieza a romperse por sitios que nadie entiende y el mío sigue creciendo sin sustos.

Para quién es esta forma de programar

Se la recomiendo a cualquiera que escriba código que tiene que durar: en producción, en una empresa, en un equipo o en un proyecto personal que quiera mantener más allá del primer mes. Y, sobre todo, a quien está aprendiendo a programar: si dejas que la Inteligencia Artificial escriba y tú no lees, no aprendes nada, y dentro de unos años no sabrás distinguir el código bueno del malo.

No hace falta para un script de usar y tirar, un prototipo para enseñar una idea o una prueba que vas a borrar mañana. Ahí, que la Inteligencia Artificial escriba y a correr. El truco está en saber distinguir una cosa de la otra, que es justo lo que hace mi skill senior-mindset antes de empezar.

Preguntas frecuentes

¿Hay que revisar el código que genera la Inteligencia Artificial?

Sí, si el código va a vivir más allá de un prototipo. La Inteligencia Artificial escribe deprisa, pero no recuerda lo que ya existe, duplica funciones y puede colar fallos de seguridad. Leerlo y entenderlo antes de aceptarlo es lo que evita que el proyecto se convierta en una deuda que nadie sabe pagar.

¿En qué se diferencia esta forma de trabajar del vibe coding?

En el vibe coding se acepta lo que escribe la Inteligencia Artificial si funciona, sin leerlo. Aquí la Inteligencia Artificial escribe, pero el programador lee, revisa, decide la arquitectura y fija las normas con las que se escribe el código.

¿Qué hacer con el tiempo que ahorra la Inteligencia Artificial al programar?

Dedicarlo a lo que ella no hace bien: revisar el código, pensar la arquitectura del software y formar a los juniors, que son los que dentro de unos años tendrán que dirigir a la Inteligencia Artificial.

¿Qué herramientas uso para programar con Inteligencia Artificial?

Empecé con GitHub Copilot y hoy uso sobre todo Claude Code, a veces Codex y, según el caso, herramientas libres. La herramienta cambia; lo importante es que el código que salga se pueda leer y entender.

Compártelo si te ha resultado útil.

¿Tú lees el código que te escribe la Inteligencia Artificial o confías en que funcione? Cuéntame.

Y… el tiempo dirá qué forma de programar aguanta mejor.