Cómo ser un 10x Programmer con IA: mi workflow completo

La IA ha cambiado radicalmente la forma en la que programo. No se trata solo de usar ChatGPT para que te genere código, sino de construir un workflow completo donde la IA se integra en cada paso del proceso de desarrollo. Esto es lo que he aprendido después de meses perfeccionando mi setup.

El problema de trabajar con IA

Usar IA para programar no es tan simple como copiar y pegar código. El principal problema que he encontrado es que si no tienes claro qué quieres implementar, la IA te va a generar código que no entiendes y que no puedes mantener.

La clave está en encontrar el punto exacto entre la abstracción y la concreción en los prompts. Si eres demasiado abstracto, la IA no sabe qué implementar. Si eres demasiado concreto, pierdes tiempo escribiendo lo que podrías haber programado tú mismo.

Mi setup: Vim + Tmux + Git Worktree

Para maximizar la productividad con IA, mi workflow se basa en tres pilares:

Vim + Tmux: Me permite tener múltiples paneles abiertos simultáneamente, cada uno con un contexto diferente. Puedo tener el código en un panel, la terminal de OpenCode en otro, y una shell para ejecutar comandos en otro.

Git Worktree: Esta es la clave para trabajar en paralelo. En lugar de hacer git checkout entre ramas, uso worktrees para tener múltiples ramas abiertas en diferentes directorios. Esto me permite trabajar en 3-4 features simultáneamente sin perder contexto.

# Crear un nuevo worktree para una feature
git worktree add ../feature-login feature/login

# Ahora puedo trabajar en ambas a la vez
cd ../feature-login  # En un panel de tmux
cd ../main          # En otro panel

Oh-my-zsh custom aliases: He configurado aliases específicos para moverme rápido entre worktrees y ejecutar comandos comunes. Por ejemplo:

alias wt='git worktree'
alias wtl='git worktree list'
alias wta='git worktree add'
alias wtr='git worktree remove'

OpenCode: Agentes especializados en Docker

OpenCode es mi herramienta principal para trabajar con IA. Lo que la hace especial es que puedo crear agentes especializados con personalidades y conocimientos específicos.

Planning Agent: Es el primero en actuar. Le paso la feature que quiero implementar y me devuelve una lista de pasos ordenados. Este agente no escribe código, solo planifica.

Architect Agent: Conoce todos los patrones de diseño y la arquitectura del proyecto al detalle. Toma el plan y decide qué clases, interfaces y módulos hay que crear o modificar, y cómo van a interactuar entre sí.

Developer Agent: Es el que más sabe de code style y clean code. Toma las decisiones del arquitecto e implementa el código siguiendo las convenciones del proyecto.

Testing Agent: Tiene una personalidad desconfiada. Su trabajo es romper el código y encontrar todos los edge cases posibles. Conoce la arquitectura y escribe tests exhaustivos.

Todos estos agentes corren en YOLO mode (ejecución automática sin confirmación) dentro de un Docker container por seguridad. Si algo sale mal, simplemente destruyo el container y empiezo de nuevo.

OpenCode Commands: Prompts a un click

He creado comandos personalizados en OpenCode para los prompts que uso frecuentemente:

/plan <feature>  # Ejecuta el Planning Agent
/arch <plan>     # Ejecuta el Architect Agent
/dev <spec>      # Ejecuta el Developer Agent
/test <code>     # Ejecuta el Testing Agent

Esto me ahorra tener que escribir el mismo prompt una y otra vez, y me asegura consistencia en cómo pido las cosas.

El arte del prompt: abstracción vs concreción

Después de meses experimentando, he encontrado que el mejor prompt es aquel donde yo tengo el mapa mental de lo que se va a implementar.

Esto significa que le explico a la IA:

• Qué clases y métodos principales quiero que implemente
• Qué relaciones va a haber entre ellos
• Dónde ponerlos exactamente en el código existente
• Cómo conectarlos con el código que ya hay

Ejemplo de mal prompt:

Implementa un sistema de autenticación

Ejemplo de buen prompt:

Implementa autenticación JWT con estos componentes:

1. AuthService en src/services/auth.service.ts con métodos:
   - login(email, password): Promise<AuthToken>
   - validateToken(token): Promise<User>

2. AuthMiddleware en src/middleware/auth.middleware.ts que:
   - Intercepta requests en /api/*
   - Valida el token usando AuthService
   - Añade user al request context

3. Conectar AuthMiddleware en src/app.ts después de bodyParser
   pero antes de los route handlers

Usa bcrypt para passwords y jsonwebtoken para tokens.

Con el segundo prompt, yo sé exactamente qué va a implementar la IA antes de que lo haga. Cuando reviso el código, solo tengo que validar que siguió mi plan, no tengo que entender desde cero qué hizo.

El workflow completo

Así es como trabajo en una feature típica:

1. Creo un worktree para la feature en una rama nueva
2. Planning Agent: "Planifica cómo implementar [feature]"
3. Architect Agent: "Diseña la arquitectura para este plan: [plan]"
4. Developer Agent: "Implementa esta arquitectura: [spec]" (aquí uso mi prompt detallado)
5. Testing Agent: "Escribe tests para este código: [código]"
6. Reviso el código en Vim mientras compilo en otro panel de Tmux
7. Si hay problemas, itero solo en el agente necesario

Con este workflow, puedo tener 3-4 features en progreso simultáneamente. Mientras un agente está ejecutándose en un worktree, yo estoy revisando código en otro.

Por qué funciona

Este workflow funciona porque:

• Especialización: Cada agente hace una cosa y la hace bien
• Paralelización: Git worktree + Tmux me permiten trabajar en varias cosas a la vez
• Seguridad: Docker containers aíslan la ejecución de la IA
• Claridad: Mis prompts detallados me dan control total sobre qué se implementa
• Velocidad: Oh-my-zsh aliases y OpenCode commands eliminan fricciones

No se trata de que la IA programe por ti, se trata de que tú dirijas a la IA para que implemente tu visión de forma más rápida. La diferencia entre un programador que usa IA mal y uno que la usa bien está en tener el mapa mental antes de ejecutar el prompt.

Conclusión

Ser un "10x programmer" con IA no es magia. Es construir un workflow que maximice tu productividad y minimice las fricciones. Requiere inversión inicial en setup, pero una vez lo tienes configurado, la velocidad de desarrollo se multiplica exponencialmente.

La clave no está en pedirle a la IA que programe por ti, sino en darle instrucciones tan claras que puedas anticipar exactamente qué va a generar. Cuando logras eso, programar con IA se convierte en una extensión de tu pensamiento.