Volver al blog
Desarrollo con IAclaude codedesarrollo con IAproductividaddebugging

Por Qué Claude Code Se Comporta Como un Junior Que No Puede Mantener Focus

Le pedí que arregle un test. Me refactorizó 8 archivos. Si Claude hace todo menos lo que pedís, no es el prompt - es cómo lo estás usando. Acá está el problema que 99% de developers no ven.

9.015 min• 1803 palabras
Max Techera

Max Techera

@maxtechera
Por Qué Claude Code Se Comporta Como un Junior Que No Puede Mantener Focus

Le pedí a Claude que arregle un test.

Me refactorizó 8 archivos, cambió la arquitectura del módulo, y creó un test suite completo.

Yo solo quería arreglar un puto test.

Si esto te suena familiar, seguí leyendo. Porque el problema no es Claude. No es tu prompt. Es algo más fundamental que 99% de developers no ven.

La Frustración Que Todos Tenemos (Pero Nadie Menciona)

Cuando le pedís algo específico a Claude y hace algo completamente diferente. No una vez. TODO EL TIEMPO.

Acá están las 5 situaciones que me pasan (y sé que a vos también):

1. "Suggest changes, don't implement"

Yo:

Analiza esta función y sugerí mejoras.
NO las implementes, solo decime qué cambiarías.

Claude:

// Acá está la función refactorizada:
export async function getUserData(id: string) {
  // 50 líneas de código nuevo
  // que no pediste
  // y ahora tenés que revisar
}

¿Le pedí que escriba código? No. ¿Lo hizo igual? Sí.

2. "Fix this test"

El test:

it('should validate email', () => {
  expect(validateEmail('test@test.com')).toBe(true);
  // Este test está fallando, arreglalo
});

Yo esperaba:

  • Que arregle el test
  • Que me diga por qué fallaba

Lo que hace Claude:

  • Cambia la lógica de validateEmail()
  • Refactoriza 3 archivos más
  • Agrega validaciones que no pediste
  • El test ahora pasa pero rompió otros 5

No arregló el test. Arregló la implementación. Que estaba bien. El test era el problema.

3. "Fix this bug"

Reporto un bug simple: el botón de logout no limpia el localStorage.

Lo que espero:

// En logout()
localStorage.clear();

Lo que hace Claude:

  • Implementa un sistema completo de session management
  • Agrega Redux para state management
  • Crea 4 archivos nuevos
  • Instala 3 dependencias
  • El bug sigue ahí porque se perdió en su propia refactor

Pedí un fix de 1 línea. Me dio una feature completa que nadie pidió.

4. "Review my code"

Le paso un PR de 200 líneas para que revise.

Lo que espero:

  • "Línea 45: este edge case no está cubierto"
  • "Línea 102: potential memory leak acá"

Lo que hace Claude:

  • "Tu código está bien pero acá está cómo lo reescribiría yo"
  • Me da 300 líneas nuevas
  • Cambia el approach completo
  • Usa patterns que no uso en el resto del codebase

No quería una reescritura. Quería un review.

5. "Document this function"

// Documenta esta función
export function processPayment(amount: number, userId: string) {
  // lógica de payment
}

Lo que espero:

/**
 * Process payment for user
 * @param amount - Amount in cents
 * @param userId - User ID
 * @returns Payment result
 */

Lo que hace Claude:

  • Agrega el JSDoc (bien)
  • Pero también refactoriza la función "para hacerla más clara"
  • Cambia el signature
  • Ahora tengo que actualizar 15 archivos que la llaman

Le pedí documentación. Me dio un refactor que rompe el codebase.

Por Qué Pasa Esto (El Problema Invisible)

Cuando programás, tu cerebro cambia constantemente entre diferentes "modos":

Code Architecture Mode: Pensando en cómo estructurar el código, DRY principles, patterns.

Testing Mode: Focus total en edge cases, coverage, qué puede fallar.

Documentation Mode: Explicar qué hace el código, cómo usarlo.

Debugging Mode: Encontrar la causa root de un bug, no parchear síntomas.

Review Mode: Encontrar problemas sin cambiar código.

Cambiás entre estos modos 50+ veces por día sin darte cuenta. Y cada modo requiere un mindset completamente diferente.

El problema con Claude (y cualquier AI) es que no respeta estos modos.

Estás en Testing Mode, enfocado en escribir un test específico. Le pedís ayuda con ese test.

Claude entra en Code Architecture Mode y empieza a refactorizar todo.

Tu focus se rompe. Ahora tenés que cambiar de modo, entender cambios que no pediste, y volver a lo que estabas haciendo.

Es Como Trabajar Con Un Junior Que No Puede Mantener Focus

La analogía perfecta:

Imaginate que tenés un junior dev en tu equipo. Le pedís algo específico:

Vos: "Arreglá este test que está fallando"

Junior: "Ah sí, pero mirá... si refactorizamos toda esta sección, el test va a ser más fácil de mantener. Además cambié esta otra cosa que vi que se podía mejorar. Ah y agregué esta feature que pensé que podría ser útil."

Vos: "...yo solo quería que arregles el test"

Junior: "Sí pero esto es mejor"

Eso es Claude. Todo el tiempo.

No es que sea malo. Es que no mantiene el focus que necesitás en ese momento.

Por Qué Esto Es Un Problema ENORME

No es solo molesto. Es un problema de productividad brutal:

Context switching mata tu velocidad

Cada vez que Claude hace algo que no pediste:

  • Tenés que leer código nuevo
  • Entender por qué lo hizo
  • Decidir si lo mantenes o rollback
  • Volver a lo que estabas haciendo
  • Tu focus se fue a la mierda

El costo real:

Un estudio encontró que después de una interrupción, toma 23 minutos volver al nivel de focus que tenías.

Si Claude te saca de focus 10 veces por día, son 230 minutos (casi 4 horas) perdidos solo volviendo a concentrarte.

Más serio aún:

Terminás confiando menos en Claude. Empezás a revisar cada cambio en detalle. Perdés la velocidad que la AI supuestamente te daba.

O peor: dejás de usarlo para cosas complejas y lo limitás a boilerplate. Estás usando 10% de su capacidad porque no te podés arriesgar a que se vaya por las ramas.

Lo Que Nadie Te Dice

Claude tiene UN context window de 200k tokens para toda la conversación.

Todos tus pedidos se acumulan ahí. Los de hace 10 mensajes contaminan los actuales:

[Mensaje 1: "Improve the architecture"]
[Mensaje 5: "Add more features"]
[Mensaje 10: "Refactor this module"]
[Mensaje 15 (actual): "Fix this test"]

Claude ve los 200k tokens completos. No sabe que cambiaste de modo 5 veces.

Ve "improve", "add", "refactor", "fix" → su cerebro mezcla todo.

Result: hace lo que cree que querés basándose en TODA la conversación, no solo en tu pedido actual.

El verdadero problema:

Además, Claude carga TODO tu codebase en ese context:

  • Los 50 archivos que podría necesitar
  • Los 1000 archivos que NO necesita
  • Docs, configs, tests, todo mezclado

Su "cerebro" está lleno de ruido. Cuando le pedís algo, tiene que filtrar entre miles de líneas irrelevantes para encontrar lo que importa.

Es como pedirle a alguien que encuentre un bug mientras lee 10 proyectos diferentes al mismo tiempo.

Si Seguís Así, Nada Cambia

Cada día perdés 4 horas en context switches. PRs con commits vagos tipo "fix stuff". Code reviews que skipeas porque "después lo veo mejor".

En 1 mes = 80 horas perdidas.

Pero hay una forma de arreglarlo...

La Solución: Sub-Agentes

¿Y si en vez de un Claude que intenta hacer todo, tuvieras especialistas?

No un context de 200k tokens mezclado.

Sino 5 contexts de 200k tokens cada uno. Aislados. Dedicados.

Los 3 sub-agentes que uso todos los días en AnswerAI:

git-expert:

  • 200k tokens SOLO para git operations
  • Ve SOLO los cambios que hiciste (git diff)
  • Acceso a Read, Bash (git commands)
  • Hace commits descriptivos, crea PRs, maneja releases
  • NO toca tu código → solo documenta cambios

code-reviewer:

  • 200k tokens SOLO para reviews
  • Ve SOLO los archivos en el diff
  • Acceso SOLO a Read y Grep
  • Analiza buenas prácticas, encuentra edge cases
  • NO refactoriza → solo reporta problemas específicos

ticket-creator:

  • 200k tokens SOLO para crear tickets
  • Explora el código relevante con Read/Grep
  • Acceso a Linear MCP (crea tickets directamente)
  • Agrega contexto técnico crítico para resolver el ticket
  • NO implementa → solo documenta lo que hay que hacer

Cada uno:

  • ✅ Context aislado (sin contaminación)
  • ✅ Tools limitados (hace SOLO lo que puede con esas tools)
  • ✅ Un trabajo específico (no se distrae)
  • ✅ Configurás VOS qué puede hacer

La magia:

Cuando limitás las tools de un agente, no solo lo limitás - lo optimizás.

El code-reviewer con solo Read/Grep no puede "decidir refactorizar". Físicamente no puede. Solo lee el diff y reporta issues.

El git-expert con Bash (git) puede commitear, pero NO puede editar código. Solo puede documentar lo que ya cambió.

El ticket-creator con Linear MCP puede crear tickets, pero NO puede implementar. Solo documenta el problema con contexto técnico.

Cada agente hace una cosa. La hace bien. No se distrae.

Esto existe. Se llama sub-agentes de Claude Code.

Y cambia completamente cómo trabajás con AI.

Lo Que Viene

En el próximo blog te muestro:

  • Cómo crear tu primer sub-agente (setup: 5 minutos)
  • Los 5 sub-agentes que más uso (con templates completos)
  • Cómo configurar tools para optimizar su ejecución
  • Templates copy-paste que podés usar hoy

Este no es hype. Lo uso daily en AnswerAI.

Casos reales de las últimas 2 semanas:

Feature completa de analytics (dashboard + API + tests):

  • Implemento el código manualmente
  • git-expert: Crea 3 commits descriptivos automáticamente
  • code-reviewer: Encuentra 2 edge cases que me olvidé
  • ticket-creator: Genera 2 tickets de follow-up en Linear con contexto técnico
  • Total: 30 minutos de "cleanup" que antes no hacía

PR de 500 líneas (refactor grande):

  • Antes: 2 horas escribiendo commit messages + self-review superficial
  • Con sub-agentes: 15 minutos
    • git-expert: commit message perfecto basado en diff
    • code-reviewer: lista de 5 issues que encontró
    • Arreglo los 5 issues en 10 minutos
  • Deploy sin bugs (antes: 1-2 hotfixes por PR grande)

Planning de nueva feature:

  • Antes: escribía tickets vagos tipo "Implement user settings"
  • Con sub-agentes: ticket-creator explora el código, agrega:
    • Archivos que hay que modificar
    • Patrones existentes a seguir
    • Edge cases a considerar
    • 3 tickets específicos en vez de 1 vago
  • Developer que lo agarra: empieza en 5 min en vez de 30min explorando

Mi workflow hoy: Implemento código → sub-agentes hacen el resto (git, review, tickets).

¿Cuánto cuesta? Plan de $200/mes, features grandes consumen todo en 1 día. ¿Vale la pena? Feature de 5 días → 7 horas. ROI claro.

¿Es solo para seniors? No. Empezá con 1 agente (git-expert hace tus commits profesionales desde el día 1).

Próximo blog: martes que viene.

Mientras tanto, comentá:

¿Cuál de estas 5 frustraciones te pasa más seguido? La 1 (suggest pero implementa), la 2 (arregla lo que no era), la 3 (fix → feature), la 4 (review → rewrite), o la 5 (docs → refactor)?

Te leo en los comentarios.

Max Techera - CTO @ AnswerAI | Enseño desarrollo con IA sin BS

PD: Si querés los templates antes del próximo blog, mandame un DM. No voy a dejar que sigas peleando con Claude una semana más.

Compartir este artículo