Estoy haciendo algunas pruebas de desarrollar proyectos pequeños sin escribir prácticamente código, pidiéndoselo todo al agente.

La intención es doble: por un lado saber si en algún momento me la experiencia se rompe mucho y tengo que tomar el control. Y por otro, aprender a pedir los cambios en incrementos del tamaño adecuado y cómo diseñar esos desarrollos incrementales.

La experiencia está siendo muy interesante y la recomiendo a todos los desarrolladores. El ciclo en un proyecto nuevo es muy diferente en uno que necesite mucho contexto, y estoy viendo también si se puede salvar esa diferencia con documentación y reglas para el agente. Pero, por ahora, mi forma de trabajar con agentes tiene como dos velocidades:

1. Red, green, refactor:

El conocido ciclo de TDD se puede seguir con el agente para dar pasos pequeños e intencionados: pides o escribes un test, compruebas que falla, pides el código, compruebas que pasa el test, miras si puedes limpiar algo, y vuelves a empezar. Este ciclo funciona incluso en proyectos grandes si tienes una buena suite de tests que te permite ir expandiéndola y trabajando así.

1. Code, Refactor, tests.

Esto es más lo que la gente llama ahora “vibe coding” pero con más estructura. Por ahora lo que he notado, en un proyecto nuevo sin reglas, es que el agente tenderá a poner todo el código junto. Es decir pides la primera versión y te pone todo el código en un fichero. Pides una nueva feature y él sigue felizmente añadiendo el código en el mismo fichero… Mi flujo ahora mismo para que esto escale es:

1. Pido la feature

2. Le pido que extraiga parte del código que ha escrito para ella a un nuevo módulo o fichero

3. Pido que escriba los tests unitarios para ese nuevo módulo

4. Reviso el código y cuando estoy contento: commit y a trabajar en la siguiente feature.

Estos son pasos mucho más grandes que los de TDD, pero al menos en proyectos pequeños de unos cuantos prompts me ha funcionado. El siguiente paso será poner ese flujo de trabajo en una regla y ver si se puede hacer en sólo tres pasos:

1. Pedir feature (aquí el agente escribe el código nuevo y luego extrae la lógica que tenga sentido extraer y escribe los tests unitarios)

2. Revisar código

3. Rollback si está mal o commit si está bien. Vuelta a 1

Este flujo puede ser muy potente si escala, seguiré contando mi experiencia para seguir aprendiendo en público, que siempre es más enriquecedor.

Me encantaría leer cómo otras personas trabajan con agentes y hasta donde han escalado sus soluciones. ¿Cómo lo haces tú?