Saltar al contenido

La inteligencia artificial se ha colado en todas las conversaciones sobre desarrollo. Después de un tiempo usándola a diario, tengo claro para qué me sirve y para qué no.

Me sirve para explorar alternativas, generar borradores de código que luego reviso, escribir pruebas repetitivas y documentar. No me sirve para decidir la arquitectura de un sistema o para fiarse del resultado sin leerlo entero.

La clave, en mi experiencia, es tratar la IA como una herramienta más: acelera el trabajo mecánico, pero la responsabilidad del código sigue siendo humana. Reviso, pruebo y ajusto todo lo que sale de un asistente, igual que haría con cualquier fragmento que copiara de otro sitio.

Desarrollo por especificaciones, no «vibe coding»

Antes de seguir, conviene aclarar una cosa, y es que esto de trabajar por especificaciones no lo ha traído la IA. Viene de mucho antes: es la ingeniería de requisitos de toda la vida, la cual habla de requisitos funcionales, no funcionales y de dominio, y de un documento de especificación (el ERS o SRS) que tiene que ser completo, consistente, no ambiguo, verificable y trazable. Lo que hace la IA, más que nada, es cambiar el ritmo al que se recorre ese camino.

El «vibe coding», por el contrario, viene a ser pedirle al asistente que te escriba algo, sin más, y quedarte con lo que salga porque parece que funciona. El problema, y no es un detalle menor, es que ese código nadie sabe por qué funciona, ni si va a seguir funcionando mañana, ni qué pasa si hay que cambiarlo. La responsabilidad, al final, se diluye.

Con el desarrollo por especificaciones, la cosa cambia: la especificación es la fuente de verdad, la IA implementa contra ella y tú verificas contra los criterios de aceptación. Hay que tener en cuenta que la verificación responde a «¿estamos construyendo bien el producto?» y la validación a «¿estamos construyendo el producto correcto?», que son dos preguntas distintas. Y la trazabilidad, la cual relaciona cada requisito con su origen, su diseño y sus pruebas, es lo que permite saber qué se rompe cuando algo se rompe.

Vamos, que la IA no sustituye el proceso: lo acelera. Lo que antes era redactar la especificación y luego picar el código, ahora es redactar la especificación, dejar que la IA genere un borrador y dedicar el tiempo a revisar, probar y ajustar. Eso sí, la spec sigue mandando, y el que firma el código sigue siendo humano.

Un ejemplo con Opencode

Para que no se quede en teoría, así es como lo tengo montado. Opencode se configura con un opencode.json en la raíz del repositorio, y ahí se le dice, más que nada, qué modelo usa, qué ficheros tiene que leer siempre y qué permisos tiene:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-sonnet-4-5",
  "instructions": [
    "AGENTS.md",
    "wordpress/ARCHITECTURE.md",
    "wordpress/CONSTRAINTS.md"
  ],
  "permission": {
    "edit": "ask",
    "bash": { "*": "ask", "git status": "allow", "git diff*": "allow" },
    "webfetch": "ask"
  }
}

El instructions, hay que tenerlo en cuenta, es lo que hace que el agente no improvise: son los ficheros de contexto que se leen en cada sesión. En este caso:

Luego está la carpeta specs/, que viene a ser el corazón del asunto: cada cambio relevante vive en su especificación, con un estado (borrador → revisada → implementada → verificada), requisitos funcionales y no funcionales, criterios de aceptación verificables y un registro de cambios. El agente, conviene aclararlo, no implementa nada sin una spec en revisada o posterior. Y alrededor hay otros ficheros que, sin ser el núcleo, también ayudan: el README.md con la metodología, la carpeta docs/ con las guías de despliegue y operación, y los propios scripts del repositorio, en su correspondiente directorio.

Del issue a la spec, y de la spec al despliegue

El circuito, más o menos, es este:

  1. Issue: se abre una issue en el repositorio (una idea, un bug, una mejora).
  2. Spec: si encaja en una spec abierta, se integra en ella; si no, se crea una nueva en borrador y se refina por rondas hasta que una relectura no deje ambigüedades.
  3. Implementación: ya en revisada, el agente implementa cumpliendo los criterios de aceptación, con cambios quirúrgicos y sin salirse del alcance.
  4. Verificación: se comprueba en producción (y en el CI) que los criterios se cumplen, y solo entonces la spec pasa a verificada.

Lo que aporta, en mi experiencia, es trazabilidad: cada línea de código se puede rastrear hasta el requisito del que sale, y cada cambio sabe qué rompe y por qué. Y encaja con el CI/CD sin inventar nada nuevo: al hacer push, el pipeline compila la imagen, pasa la auditoría de accesibilidad y despliega. Lo que cambia con la IA no es el proceso, es la velocidad a la que se recorre: el agente escribe el borrador y tú revisas contra los criterios de aceptación.