Claude Code + boilerplate: el flujo del nuevo AI builder

El flujo del nuevo AI builder en 2026 no es "abrir VS Code y empezar a teclear". Es abrir Claude Code y dejar que el agente arranque sobre tu boilerplate. La diferencia de productividad es brutal.

Esta guía explica el flujo concreto: cómo se trabaja en un boilerplate AI-native con Claude Code, qué hace el humano y qué hace el agente.

El flujo end-to-end

Humano                                     Agente
─────────────                              ─────────────
1. Idea / requisito
2. Prompt corto
                                           3. Lee CLAUDE.md raíz
                                           4. Lee CLAUDE.md de la feature
                                           5. Plantea plan
6. Aprueba o ajusta
                                           7. Implementa siguiendo patterns
                                           8. Lanza /verify
                                           9. Corrige errores
10. Revisa PR
                                           11. Hace commit
12. Merge

El humano hace 4 cosas: idea, prompt, aprobar plan, revisar PR. Todo lo demás lo hace el agente.

Paso 1: arranca Claude Code

cd my-saas
claude

Claude lee automáticamente:

• CLAUDE.md raíz
• ~/.claude/CLAUDE.md (tus instrucciones globales)
• .claude/rules/*.md si existen
• Skills y agents disponibles

Eso es contexto que no tienes que repetir.

Paso 2: prompt mínimo

Ya no hace falta soltar el contexto entero. Esto basta:

"Añade un endpoint para suscribirse al newsletter siguiendo los patrones del proyecto"

El agente sabe:

• Que tu boilerplate usa createApiHandler
• Que los emails se envían con Resend
• Que los datos van a Prisma
• Que los errores se loggean con @/lib/errors/logger

Tú solo dices QUÉ. El cómo lo saca de CLAUDE.md.

Paso 3: revisión del plan

Antes de teclear, el agente plantea un plan corto:

"Voy a crear:

• src/app/api/newsletter/subscribe/route.ts con createApiHandler
• schema de Zod para email
• llamada a Resend para confirmar suscripción
• log de éxito/error ¿Procedo?"

Si está bien → "sí". Si falta algo → lo corriges en una línea. No has tecleado código.

Paso 4: implementación + verificación

El agente implementa. Luego lanza /verify o el comando equivalente. Si falla:

• Lee el error
• Lo arregla
• Reintenta

Tú lees el resultado, no el proceso.

Paso 5: commit y PR

Si tienes la regla "siempre commitea con conventional commits y abre PR", el agente:

• Hace git add selectivo
• Escribe mensaje descriptivo
• Abre PR con resumen + test plan

Tú haces merge cuando lo revises.

Qué cambia respecto a Cursor / Copilot

No es lo mismo "asistente de teclado" que "ingeniero junior con tu repo en la cabeza".

Errores típicos del flujo

1. No tener CLAUDE.md y escribir prompts genéricos: el agente improvisa, te toca corregir.

2. Saltarse el plan: si dejas que el agente vaya directo a código, te toca revisar mucho. Pide siempre el plan primero.

3. Aceptar PRs sin revisar: el agente es senior, no infalible. Lee al menos los archivos clave antes del merge.

4. No actualizar CLAUDE.md: cuando ves que el agente comete el mismo fallo 3 veces, la regla no está. Añádela.

Conclusión

El flujo Claude Code + boilerplate AI-native es lo que separa hoy a los AI builders rápidos del resto. No es magia: es disciplina sobre dónde viven las reglas.

Si tu repo está preparado, sacas features en horas que antes te llevaban días. Si no lo está, sigues "ayudándote con la IA" en lugar de construir con ella.

La línea es fina. Pero está clarísima.