Ejecuto 15 Clones de IA de Mí Mismo en Paralelo — Y Ni Siquiera Es Mi Forma Final

"¡Pero Opus es más lento!" grita la voz interior de cada desarrollador que alguna vez ha hecho benchmarks de tiempos de respuesta.

¿El argumento de Boris? Las matemáticas funcionan diferente cuando factorizas el tiempo humano:

Sonnet (modelo más rápido):
Solicitud: 30 segundos
× 5 iteraciones (dirigir, corregir)
= 2.5 minutos + tu cordura

Opus (modelo más lento):
Solicitud: 2 minutos
× 1 iteración (lo hace bien la primera vez)
= 2 minutos + tu cordura intacta

La perspectiva clave: el cuello de botella no es el tiempo de procesamiento de IA — es el tiempo humano gastado dirigiendo y corrigiendo. Opus requiere menos supervisión, toma mejores decisiones de uso de herramientas, y generalmente no necesita que le digas "no, así no" diecisiete veces por tarea.

Es como la diferencia entre un desarrollador junior que es rápido pero necesita revisión constante de código, versus un senior que es más lento pero envía código listo para producción. Excepto que el senior es una IA y puedes ejecutar quince de ellos en paralelo.

CLAUDE.md: La Memoria Colectiva de Tu Base de Código

Aquí es donde se vuelve genuinamente brillante.

El equipo de Claude Code mantiene un solo archivo CLAUDE.md, registrado en git, al que todo el equipo contribuye múltiples veces por semana. Piénsalo como un documento vivo que captura cada lección de "no hagas eso" que Claude aprende.

Claude comete error →
Desarrollador lo nota →
Agregar patrón a CLAUDE.md →
Commit a git →
Claude lo lee en la próxima sesión →
Claude nunca comete ese error otra vez

Es como tener un desarrollador nuevo que nunca olvida nada de lo que le dices y comparte ese conocimiento con cada otra instancia de sí mismo a través del tiempo y el espacio.

¿Qué Va en CLAUDE.md?

Boris reveló las especificaciones reales: su CLAUDE.md tiene 2.5k tokens y cubre:

- Comandos bash comunes
- Convenciones de estilo de código
- Pautas de diseño de UI y contenido
- Cómo hacer gestión de estado, logging, manejo de errores, gating y debugging
- Plantilla de pull request

Eso es todo. No una novela — un documento de referencia enfocado.

## Estructura del Proyecto
- /src contiene código de aplicación
- /tests refleja la estructura de /src

## Comandos Comunes
- npm run build: Construir el proyecto
- npm run test: Ejecutar suite de pruebas
- npm run lint: Ejecutar linter con auto-fix

## Nuestras Convenciones
- Usamos modo estricto de TypeScript en todas partes
- Preferir const sobre let, siempre
- Los nombres de función deben ser verbos

## Cosas Que Claude Ha Hecho Mal Antes
- No usar APIs deprecadas (aquí está la lista...)
- Nunca modificar el directorio .claude/ directamente
- Siempre ejecutar pruebas antes de sugerir un commit

El equipo incluso usa una GitHub Action para etiquetar automáticamente @.claude durante revisiones de código, pidiéndole que actualice el CLAUDE.md basado en patrones encontrados en PRs. Cada revisión de código se convierte en una oportunidad de aprendizaje que se compone con el tiempo.

Como notó un observador: "Cada error se convierte en una regla. Mientras más tiempo trabaja el equipo junto, más inteligente se vuelve el agente."

Es básicamente RLHF, pero conducido por todo tu equipo de ingeniería a través de revisiones de código.

El Flujo de Trabajo de Dos Fases: Piensa Primero, Envía Después

Boris no simplemente se lanza de cabeza a través de prompts. Ha desarrollado un enfoque disciplinado de dos fases:

Fase 1: Modo Plan (Interactivo)

[Shift+Tab][Shift+Tab] — entra en modo Plan

Tú: "Necesito agregar autenticación OAuth"

Claude: "Aquí está mi plan:
1. Instalar passport-oauth2
2. Crear archivo de configuración OAuth
3. Agregar rutas /auth/login y /auth/callback
4. Actualizar modelo de usuario para datos OAuth
5. Crear middleware de auth
6. Actualizar frontend con botón de login
7. Agregar pruebas"

Tú: "Se ve bien, pero agrega refresh tokens también"

Claude: *actualiza plan*

Fase 2: Modo Ejecutar (Autónomo)

Una vez que el plan es aprobado, Boris cambia a modo auto-aceptar. Claude entonces ejecuta todo el plan, a menudo de una sola vez.

La filosofía es simple: invierte tiempo por adelantado en planificación, ahorra mucho más tiempo en ejecución. Es la versión potenciada por IA del adagio del carpintero: mide dos veces, corta una vez. Excepto que aquí es: planifica interactivamente, codifica autónomamente.

Un buen plan es realmente importante, enfatiza Boris. Y tiene razón — un plan bien estructurado significa que Claude puede encadenar docenas de ediciones de archivos sin necesitar intervención humana en cada paso.

Comandos Slash: Porque Escribir Es Para Gente Con Tiempo

Boris aclaró en los comentarios: "Skills = comandos slash, los uso intercambiablemente." Lo mismo, nombres diferentes.

Boris ha automatizado cada flujo de trabajo de "bucle interno" en comandos slash que viven en .claude/commands/:

---
description: Hacer commit de cambios, push a remoto, y crear PR
---

# Estado de Git
!`git status --short`

# Rama Actual
!`git branch --show-current`

# Commits Recientes
!`git log -5 --oneline`

Basado en el estado de git arriba:
1. Hacer stage y commit de cambios con mensaje descriptivo
2. Push a remoto
3. Crear PR con título y descripción claros
4. Solicitar revisión de miembros apropiados del equipo

El bash inline (esos comandos !) pre-computa contexto para que Claude no necesite preguntar. Ve el estado de git, conoce la rama actual, entiende el historial reciente — y puede tomar decisiones inteligentes inmediatamente.

Boris usa /commit-push-pr docenas de veces cada día. Eso son docenas de flujos de trabajo git multi-paso reducidos a siete pulsaciones de tecla.

Otros comandos de su configuración:

• /quick-commit — Stage todo y commit con mensaje auto-generado
• /test-and-fix — Ejecutar pruebas, arreglar fallas, repetir hasta verde
• /review-changes — Revisar cambios sin commit y sugerir mejoras
• /first-principles — Deconstruir problemas a verdades fundamentales

Estos están registrados en git y compartidos a través del equipo. Todos se benefician de las optimizaciones de flujo de trabajo de todos.

Subagentes: Colegas de IA Especializados

Más allá de los comandos slash, Boris usa subagentes — asistentes de IA especializados con sus propios prompts de sistema, acceso a herramientas, y ventanas de contexto separadas.

AgentePropósitocode-simplifierSimplifica código después de que Claude termina de trabajarverify-appPrueba exhaustivamente que la aplicación funciona correctamentecode-architectRevisiones de diseño y decisiones arquitectónicasbuild-validatorAsegura que el proyecto se construya correctamente para deploymentoncall-guideAyuda a diagnosticar y resolver problemas de producción

Piénsalos como expertos especializados que puedes llamar para tareas específicas. El code-simplifier se ejecuta después de cada feature para reducir complejidad. El agente verify-app tiene instrucciones detalladas para probar Claude Code de extremo a extremo.

La diferencia clave de los comandos slash: los subagentes tienen su propia ventana de contexto, así que no contaminan tu conversación principal. Son verdaderamente trabajadores separados manejando trabajos específicos.

Hooks: La Capa de Automatización Definitiva

Claude Code soporta hooks — acciones automatizadas que se ejecutan en puntos específicos del flujo de trabajo. Boris usa un hook PostToolUse para auto-formatear código:

{
"hooks": {
"PostToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "command",
"command": "npx prettier --write \"$CLAUDE_FILE_PATH\""
}]
}]
}
}

Cada vez que Claude edita o escribe un archivo, Prettier automáticamente lo formatea. Esto atrapa el último 10% de problemas de formateo, previniendo fallas de CI sin ninguna intervención humana.

Sin hook:

Claude escribe código → Push a PR → CI falla en formateo →
Arreglar formateo → Push otra vez → CI pasa

Con hook:

Claude escribe código → Hook formatea → Push a PR → CI pasa ✓

Es la diferencia entre limpiar después de tu aspiradora robot y tener un robot que se limpia después de sí mismo.

El Sistema de Permisos: Seguridad Sin Fricción

Boris explícitamente evita --dangerously-skip-permissions. En su lugar, usa /permissions para pre-permitir comandos seguros específicos:

{
"permissions": {
"allowedTools": {
"Bash": {
"allowedCommands": [
"git status",
"git diff",
"git commit",
"npm test",
"npm run build",
"npm run lint"
]
},
"Edit": { "allowed": true },
"Read": { "allowed": true }
}
}
}

Esto te da la conveniencia de auto-aprobación para operaciones que sabes que son seguras, mientras aún requiere permiso explícito para cualquier cosa inusual. Es como darle a tu IA un juego de llaves de casa en lugar de los códigos de lanzamiento nuclear.

Integración MCP: La Conexión de Claude a Todo

Claude Code usa MCP (Model Context Protocol) para conectarse a herramientas externas. La configuración de Boris incluye:

• Slack — Publicar actualizaciones, notificaciones, buscar conversaciones
• BigQuery — Ejecutar consultas de analytics vía CLI bq
• Sentry — Obtener logs de error directamente
• Simuladores iOS/Android — para verificación de apps móviles (sí, hay MCPs para eso)

{
"mcpServers": {
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-...",
"SLACK_TEAM_ID": "T..."
}
}
}
}

Ahora Claude puede hacer cosas como:

> Hacer deploy a staging y notificar al equipo en #deployments

Claude: [Ejecuta deployment]
Claude: [Usa servidor MCP de Slack]
Claude: [Publica en canal #deployments]
✓ Deployment completo, equipo notificado

El archivo .mcp.json está registrado en git. Todo el equipo obtiene estas integraciones automáticamente.

El Método Ralph Wiggum: Para Cuando Necesitas IA Que Simplemente No Se Rinde

Para tareas de muy larga duración, Boris usa algo llamado el plugin Ralph Wiggum. Nombrado por el personaje de Los Simpson que persiste alegremente a pesar de todos los obstáculos, crea un bucle iterativo que mantiene a Claude funcionando hasta que una tarea está realmente completa.

El concepto:

Iteración 1:
Claude: [Implementa API básica]
Claude: [Trata de salir]
Stop Hook: [Pruebas fallando - bloquear salida]
Stop Hook: [Alimentar mismo prompt de vuelta]

Iteración 2:
Claude: [Ve fallas de pruebas]
Claude: [Arregla bugs]
Claude: [Trata de salir]
Stop Hook: [Algunas pruebas aún fallando - bloquear salida]

Iteración 3:
Claude: [Arregla bugs restantes]
Claude: [Todas las pruebas pasando]
Claude: [Produce COMPLETE]
Stop Hook: [Promesa de completación detectada - permitir salida]
✓ ¡Hecho!

Para estas sesiones autónomas de larga duración, Boris usa ya sea --permission-mode=dontAsk o --dangerously-skip-permissions — pero solo en entornos aislados, en sandbox.

La Regla de Oro: Dale a Claude un Bucle de Verificación

Aquí está el consejo más importante de Boris, y lo guardó para el final:

Dale a Claude una forma de verificar su trabajo. Si Claude tiene ese bucle de retroalimentación, mejorará 2–3x la calidad del resultado final.

Esta es la salsa secreta que hace que todo lo demás funcione.

Sin verificación:

Claude escribe código → Push a PR →
CI falla → Bugs en producción →
Debugging manual requerido

Con verificación:

Claude escribe código → Lo prueba →
Ve fallas → Las arregla →
Re-prueba → Itera hasta que pase →
Código de alta calidad

La verificación se ve diferente para cada dominio:

• Herramientas CLI: Ejecutar el comando, verificar output
• APIs: Hacer requests, verificar respuestas
• UI: Usar extensión Chrome de Claude para probar visualmente
• Backend: Ejecutar suite de pruebas, verificar cobertura
• Apps móviles: Usar MCPs de simulador iOS/Android para probar en dispositivo itera hasta que el código funciona y la UX se siente bien.

Invierte en hacer la verificación sólida como una roca. Es la mejora individual de mayor apalancamiento que puedes hacer al desarrollo asistido por IA.

El Stack Completo: Todo Junto

Aquí está la configuración completa de Boris en una vista:

1. 15+ Sesiones Paralelas — Terminal, web, iOS
2. Opus 4.5 + Pensamiento Extendido — Mejor modelo, más rápido en general
3. CLAUDE.md del Equipo — Base de conocimiento compartida, controlada por versiones
4. GitHub Action — Auto-actualizar CLAUDE.md desde PRs
5. Modo Plan → Auto-Aceptar — Flujo de trabajo de dos fases
6. Comandos Slash — Automatizar flujos de trabajo repetidos
7. Subagentes — Asistentes de IA especializados
8. Hook PostToolUse — Auto-formatear código
9. Permisos Inteligentes — Pre-permitir comandos seguros
10. Integración MCP — Conectar a Slack, BigQuery, Sentry
11. Ralph Wiggum — Bucles iterativos para tareas largas
12. Verificación — Más importante: bucles de retroalimentación en todas partes

Qué Significa Esto Para el Resto de Nosotros

La reacción al hilo de Boris ha sido… intensa.

"Si no estás leyendo las mejores prácticas de Claude Code directamente de su creador, estás atrasado como programador," escribió un observador de la industria.

"Este es potencialmente su momento ChatGPT," declaró otro.

La emoción surge de una paradoja: el flujo de trabajo de Boris es sorprendentemente simple, pero permite a un solo humano operar con la capacidad de output de un pequeño departamento de ingeniería.

En los últimos treinta días, Boris aterrizó 259 PRs — 497 commits, 40k líneas agregadas, 38k líneas removidas. Cada línea fue escrita por Claude Code + Opus 4.5.

Eso no es un flujo de trabajo. Eso es un multiplicador de fuerza.

Comenzando (Sin Quemar Tu Casa)

No necesitas implementar todo a la vez. Comienza pequeño:

1. Crea un CLAUDE.md — Documenta las convenciones de tu proyecto
2. Configura un comando slash — Automatiza algo que haces diariamente
3. Agrega verificación — Dale a Claude una forma de probar su trabajo
4. Configura permisos — Pre-permite comandos seguros
5. Agrega un hook — Auto-formatea código al guardar

Luego itera. Agrega más comandos slash conforme emergen patrones. Crea subagentes para tareas especializadas. Expande tus integraciones MCP.

El objetivo no es igualar la configuración de Boris — es construir tu propia máquina de aprendizaje compuesto que mejore cada día.

La Tasa de Falla de la Que Nadie Habla

Cuando se le preguntó qué porcentaje de sesiones abandona, Boris respondió: "¿Tal vez como 10–20%?"

Incluso el creador de Claude Code no tiene una tasa de éxito del 100%. Algunas sesiones simplemente no funcionan. Eso es normal. Las ganancias de productividad vienen del 80% que sí funciona.

Pensamientos Finales

Lo que Boris ha demostrado no es solo un hack de productividad. Es un vistazo a un modelo completamente diferente de desarrollo de software.

Por años, "codificación con IA" significaba autocompletado — una forma más rápida de escribir. Lo que Boris muestra es que la IA ahora puede funcionar como un sistema operativo para el trabajo mismo.

"Lee esto si ya eres ingeniero y quieres más poder," resumió un comentarista.

Las herramientas para multiplicar el output humano por 5x están aquí. Solo requieren la voluntad de dejar de pensar en la IA como un asistente y comenzar a tratarla como una fuerza laboral.

Los programadores que hagan ese salto mental primero no solo serán más productivos. Estarán jugando un juego completamente diferente.

Y todos los demás seguirán escribiendo.

Originalmente basado en el hilo de Twitter de Boris Cherny. Boris es el creador y jefe de Claude Code en Anthropic.

Recursos

• Documentación de Claude Code
• Referencia de Comandos Slash
• Guía de Subagentes
• Guía de Hooks
• Documentación MCP
• Plugin Ralph Wiggum
• Extensión Chrome de Claude
• Configuración de Boris (Repo Comunitario)

Si disfrutaste este desglose, dale clap 50 veces y sígueme para más análisis profundos sobre desarrollo potenciado por IA. Tus receptores de dopamina te lo agradecerán.

Descubre cómo un desarrollador maneja 15 clones de IA simultáneamente sin morir en el intento. Lecciones reales de producción que transforman el caos en código.

→ Únete a la newsletter de desarrollo con IA