Módulo 4: El workflow agentic: Explore → Plan → Code

Módulo 4: El workflow agentic — Explore → Plan → Code

Siguiente →

Módulo 4: El workflow agentic — Explore → Plan → Code

Descripción

Has instalado Claude Code. Configuraste tu CLAUDE.md. Tu agente ya tiene memoria y contexto sobre tu proyecto. Ahora viene la pregunta que separa a los usuarios casuales de los profesionales: ¿cómo trabajas con Claude Code de manera efectiva?

Este módulo enseña el workflow agentic — el ciclo Explore → Plan → Code que define cómo se trabaja profesionalmente con un agente de código. No es un framework teórico: es la forma en que Claude Code está diseñado para operar, y dominar este ciclo es la diferencia entre obtener resultados mediocres y resultados de nivel producción.

La mayoría de personas abren Claude Code, escriben un prompt, y esperan magia. Eso funciona para tareas triviales. Pero cuando el proyecto es real — con dependencias, convenciones, tests, y arquitectura existente — necesitas un workflow estructurado. Explore → Plan → Code es ese workflow.

Dónde estamos en la guía

Módulo 01: Qué es Claude Code ✅
Módulo 02: Instalación y setup ✅
Módulo 03: CLAUDE.md y memoria ✅
Módulo 04: Workflow agentic ← ESTÁS AQUÍ
Módulo 05: Skills y Hooks
Módulo 06: Subagents
Módulo 07: Integraciones (Git, SDK, Remote Control)
Módulo 08: Proyecto integrador

En los primeros tres módulos entendiste qué es Claude Code, lo instalaste, y configuraste su sistema de memoria. Ahora pasamos de configurar a usar. Este módulo es el corazón operativo de la guía: todo lo que viene después (skills, hooks, subagents) se ejecuta dentro de este workflow.

Objetivo del módulo

Al completar este módulo, serás capaz de:

  • ✅ Usar los 3 modos de Claude Code: Explore (análisis read-only), Plan (diseño sin ejecución), y Agent/Code (ejecución completa)
  • ✅ Aplicar el ciclo Explore → Plan → Code en proyectos reales
  • ✅ Realizar multi-turn conversations efectivas (iterar y refinar en múltiples mensajes)
  • ✅ Gestionar el context window (entender compaction, señales de degradación)
  • ✅ Decidir cuándo empezar una sesión nueva vs continuar la actual
  • ✅ Usar el parámetro /effort para controlar la profundidad de razonamiento

El mental model fundamental

Claude Code no es un chatbot. Es un agente con un workflow definido.

Esta distinción es crítica. Un chatbot recibe un mensaje, genera una respuesta, y espera el siguiente mensaje. Claude Code hace algo radicalmente diferente:

  1. Lee tu codebase — archivos, dependencias, configuración, tests
  2. Ejecuta comandos — terminal, scripts, herramientas del ecosistema
  3. Escribe código — crea archivos, modifica código existente, genera tests
  4. Itera — refina la solución basándose en feedback, errores, y resultados

Esto significa que la forma en que le das instrucciones importa tanto como las instrucciones mismas. No estás "chateando" — estás dirigiendo un agente que tiene acceso completo a tu entorno de desarrollo.

Analogía precisa

Piensa en Claude Code como un developer senior que acaba de unirse a tu equipo. No le dices "haz la feature X" sin contexto. Primero le pides que explore el codebase, luego que proponga un plan, y finalmente que implemente. Exactamente ese es el ciclo Explore → Plan → Code.

El error más común

La mayoría de usuarios hacen esto:

> "Agrega autenticación a mi app"

Un profesional hace esto:

Paso 1 (Explore): "Analiza la estructura actual del proyecto. 
¿Qué framework se usa? ¿Hay algún sistema de auth existente? 
¿Cómo se manejan las rutas protegidas?"

Paso 2 (Plan): "Basándote en lo que encontraste, diseña un plan 
para agregar autenticación con JWT. No implementes nada todavía, 
solo dame el plan."

Paso 3 (Code): "Implementa el plan. Empieza por el middleware 
de autenticación."

El segundo enfoque produce resultados dramáticamente mejores porque Claude Code entiende el contexto antes de actuar.

Por qué existe este workflow

El ciclo Explore → Plan → Code no es una invención pedagógica. Refleja cómo funciona internamente Claude Code y cómo los equipos de ingeniería de Anthropic diseñaron la herramienta para ser usada.

El problema que resuelve

Cuando le das a Claude Code una instrucción directa ("agrega X"), el agente tiene que hacer todo al mismo tiempo: entender el contexto, diseñar la solución, e implementarla. Esto funciona si la tarea es trivial. Pero si la tarea es compleja, el agente toma decisiones de diseño implícitas — sin consultarte — y el resultado depende de suerte.

Con el workflow Explore → Plan → Code, separas las decisiones en fases:

FaseDecisiones que se toman
Explore¿Qué existe? ¿Qué patterns se usan? ¿Qué restricciones hay?
Plan¿Cómo deberíamos implementarlo? ¿Qué opciones hay? ¿Cuáles son los trade-offs?
CodeImplementación pura — las decisiones de diseño ya están tomadas

Cada fase reduce incertidumbre. Para cuando llegas a Code, Claude sabe exactamente qué hacer y cómo.

La evidencia

Los datos internos de Anthropic y la comunidad de Claude Code reportan consistentemente:

  • Las sesiones que empiezan con Explore producen menos iteraciones correctivas
  • Los plans revisados antes de implementar reducen refactoring post-implementación
  • El uso de /effort apropiado reduce el consumo de context window en tareas simples

No es dogma — es eficiencia medible.

Cuándo NO necesitas el ciclo completo

No todo requiere Explore → Plan → Code. Estas situaciones justifican ir directo a Code:

  • Typo fix: "Cambia recieve a receive en el archivo X"
  • Boilerplate: "Crea un modelo User con name, email, y created_at"
  • Ejecución: "Ejecuta npm test y muéstrame los resultados"
  • Pregunta simple: "¿Qué versión de Python usa este proyecto?"

La regla práctica: si la tarea requiere decisiones de diseño, usa el ciclo. Si es mecánica, ve directo.

Los 3 modos de Claude Code

Claude Code opera en tres modos distintos. Cada uno tiene un propósito específico:

Explore (análisis read-only)

  • Qué hace: Lee archivos, analiza arquitectura, busca patterns. No ejecuta ni escribe.
  • Cuándo usarlo: Al iniciar un proyecto, antes de hacer cambios, para entender código ajeno.
  • Cómo activarlo: Pide a Claude que analice, explore, o entienda sin pedir cambios.
  • Subagent: Claude Code tiene un subagent built-in de Explore que opera en modo read-only.

Plan (diseño sin ejecución)

  • Qué hace: Propone cambios, crea planes de implementación, sugiere arquitectura. No ejecuta.
  • Cuándo usarlo: Antes de implementar features complejos, refactorizaciones, migraciones.
  • Cómo activarlo: Usa /plan, presiona Shift+Tab, o pide explícitamente que planifique sin implementar.
  • Output: Plan estructurado que puedes revisar, modificar, y aprobar antes de ejecutar.

Agent/Code (ejecución completa)

  • Qué hace: Lee, escribe, ejecuta comandos. Es el modo por defecto.
  • Cuándo usarlo: Implementación, bug fixes, escribir tests, crear archivos.
  • Permisos: Claude pide confirmación antes de ejecutar comandos y editar archivos.

Estos tres modos no son features separados — son fases de un ciclo. La cápsula 02 los cubre en profundidad con ejemplos prácticos.

Vista rápida: el flujo de los 3 modos

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  EXPLORE          PLAN             CODE                     │
│  ┌──────────┐     ┌──────────┐     ┌──────────┐            │
│  │ Lee      │     │ Diseña   │     │ Implementa│            │
│  │ Analiza  │────▶│ Propone  │────▶│ Ejecuta   │            │
│  │ Entiende │     │ Compara  │     │ Escribe   │            │
│  └──────────┘     └──────────┘     └──────────┘            │
│       ▲                                  │                  │
│       │           ITERAR                 │                  │
│       └──────────────────────────────────┘                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Cada modo tiene permisos diferentes:

ModoLee archivosEscribe archivosEjecuta comandos
Explore✅❌❌
Plan✅❌❌
Agent/Code✅✅✅

Explore y Plan son seguros por diseño — no pueden modificar nada. Agent/Code tiene acceso completo pero pide confirmación para acciones potencialmente destructivas.

Prerequisitos

Conocimiento requerido:

  • ✅ Módulo 03 completado (CLAUDE.md configurado en tu proyecto)
  • ✅ Claude Code instalado y funcionando (Módulo 02)
  • ✅ Familiaridad básica con terminal

Para la práctica:

  • ✅ Un proyecto real para practicar (el que configuraste con CLAUDE.md en el Módulo 03)
  • ✅ Al menos 10-15 archivos en el proyecto (para que Explore tenga material)

Verificación rápida:

Antes de continuar, verifica que puedes responder estas preguntas:

  1. ¿Qué es CLAUDE.md y para qué sirve?
  2. ¿Cuáles son los 4 scopes oficiales de CLAUDE.md?
  3. ¿Dónde se ubica CLAUDE.local.md y por qué?
Respuestas
  1. CLAUDE.md es el archivo de memoria persistente donde defines convenciones, stack tecnológico, y reglas del proyecto. Claude Code lo lee al inicio de cada sesión.
  2. 4 scopes oficiales: Managed policy (organización) → Project (./CLAUDE.md o ./.claude/CLAUDE.md) → User (~/.claude/CLAUDE.md) → Local (./CLAUDE.local.md). Adicionalmente, .claude/rules/ permite reglas modulares con path-specific frontmatter. Conceptualmente hay 6 niveles pedagógicos de precedencia (incluyendo training data y system prompt).
  3. En la raíz del proyecto, junto a CLAUDE.md. Se agrega a .gitignore porque contiene preferencias personales no compartidas con el equipo. Alternativamente, ~/.claude/CLAUDE.md (User scope) permite preferencias que aplican a todos tus proyectos.

Si no estás listo:

Revisa primero:

  • Módulo 02: Instalación y setup
  • Módulo 03: CLAUDE.md y el sistema de memoria

Roadmap del módulo

Este módulo tiene 5 cápsulas progresivas:

Cápsula 01 — Introducción al módulo (esta cápsula)

Contexto, mental model, y roadmap. Entiendes por qué el workflow importa.

Cápsula 02 — Explore, Plan y Code

Los tres modos en profundidad. Cómo activar cada uno, cuándo usarlos, y cómo combinarlos. El parámetro /effort para controlar la profundidad de razonamiento. Ejemplos prácticos y ejercicios.

Cápsula 03 — Multi-turn conversations

Cómo iterar con Claude Code en múltiples mensajes. Técnicas de refinamiento incremental, cómo dar feedback efectivo, y patterns para conversaciones productivas. La diferencia entre one-shot prompts y conversaciones multi-turn.

Cápsula 04 — Context window y compaction

El context window de Claude Code (hasta 1M tokens con Opus 5 y Sonnet 5). Qué es compaction, cuándo ocurre automáticamente, señales de degradación, y estrategias para gestionar el contexto en proyectos grandes.

Cápsula 05 — Cuándo empezar nueva sesión

Indicadores de que debes iniciar una sesión nueva. Cómo preservar lo importante al reiniciar. Estrategias para sesiones largas vs cortas. La regla del "context poisoning".

Mapa de progresión

Cápsula 01 (esta)     → Mental model y contexto
Cápsula 02            → Los 3 modos en profundidad + /effort
Cápsula 03            → Multi-turn: iterar efectivamente
Cápsula 04            → Context window: el recurso finito
Cápsula 05            → Cuándo reiniciar: la habilidad invisible

Dificultad: ⭐ ──────────────────────────▶ ⭐⭐⭐

Las primeras dos cápsulas son fundamentales — entiendes y practicas los modos. Las cápsulas 03-05 son intermediate — optimizan tu uso del workflow para sesiones reales de trabajo.

Qué construirás en este módulo

A lo largo de las 5 cápsulas, practicarás el workflow completo en tu proyecto real:

  1. Explorarás tu codebase con Claude Code en modo Explore
  2. Planificarás una feature o mejora usando Plan mode
  3. Implementarás el plan usando Agent mode
  4. Iterarás en una conversación multi-turn para refinar
  5. Gestionarás el context window durante una sesión real

Al final del módulo, tendrás la experiencia de haber completado un ciclo Explore → Plan → Code de principio a fin.

Conexión con el proyecto integrador

En el Módulo 08, construirás una herramienta CLI completa usando Claude Code. El workflow que aprendes en este módulo es exactamente el que aplicarás:

  1. Explore: Analizar el template inicial del proyecto CLI
  2. Plan: Diseñar los comandos, la estructura, y la arquitectura
  3. Code: Implementar comando por comando
  4. Iterate: Refinar cada comando con multi-turn conversations
  5. Manage context: Saber cuándo empezar sesiones nuevas durante un proyecto multi-sesión

El workflow Explore → Plan → Code no es solo para este módulo — es la metodología que usarás en todo tu trabajo profesional con Claude Code.

Conceptos clave que verás

El ciclo Explore → Plan → Code

El workflow central. No es lineal — es iterativo. A veces vuelves a Explore después de Code. A veces haces Explore → Code directamente para bug fixes. Aprenderás cuándo usar cada variación.

Multi-turn conversations

Claude Code no es para one-shot prompts. Las conversaciones de 10, 20, incluso 50 mensajes son normales en un proyecto real. Aprenderás a mantener estas conversaciones productivas.

Context window finito

Incluso con 1M tokens (Opus 5 y Sonnet 5), el context window se llena. Cuando se llena, Claude comprime (compaction). Cuando la compresión degrada la calidad, necesitas una sesión nueva. Saber leer estas señales es una habilidad profesional.

Effort level (Opus y Sonnet)

Claude Code soporta múltiples niveles de effort que controlan cuánto razona el modelo antes de responder. Los niveles disponibles dependen del modelo:

NivelUsoDisponible
lowTareas rutinarias, respuestas directas✅
mediumBalance velocidad/profundidad✅
highRazonamiento profundo, trabajo intelligence-sensitive (default)✅
xhighMuy profundo, recomendado para coding/agentic✅
maxMáxima profundidad, sin límite de tokens de thinking✅

Default: high en los modelos que soportan effort (Opus 5, Sonnet 5, Fable 5); xhigh es el recomendado para coding/agentic. Haiku 4.5 no expone effort configurable.

Se configura con /effort, en /model con las flechas ← →, en settings (effortLevel), o por env var (CLAUDE_CODE_EFFORT_LEVEL). Aprenderás a usarlo en la cápsula 02.

Cuándo empezar una sesión nueva

Esta es quizás la habilidad más subestimada. Seguir en una sesión degradada produce código peor que empezar de cero. Aprenderás los indicadores exactos.

Un día real con el workflow

Para que visualices cómo se integra todo, aquí tienes un escenario real de una sesión de trabajo de 2 horas:

9:00 — Nueva sesión, nueva feature

Abres Claude Code en tu proyecto. Necesitas agregar un endpoint de búsqueda con filtros.

> Analiza el módulo de productos. ¿Cómo están implementados los 
  endpoints actuales? ¿Se usa algún patrón de query? ¿Hay 
  paginación?

Claude explora y te da un mapa completo. Descubres que hay paginación básica pero no hay filtros.

9:10 — Plan

/plan Diseña un endpoint GET /api/products/search con filtros 
por nombre, categoría, precio min/max, y ordenamiento. Debe 
usar la paginación que ya existe.

Claude produce un plan de 5 pasos. Lo revisas, pides un ajuste al manejo de precio, y apruebas.

9:20 — Implementación incremental

> Implementa el paso 1: el schema de búsqueda con los filtros.

> Ahora el paso 2: la query en el service layer.

> Paso 3: el endpoint en el router. Ejecuta tests después.

9:50 — Verificación

> Revisa la implementación completa. ¿Los tests cubren todos 
  los filtros? ¿Hay edge cases con precio negativo o strings 
  vacíos?

Claude detecta que no hay validación para precio negativo. Lo arreglas.

10:00 — Commit y siguiente tarea

> Haz commit con un mensaje descriptivo.

Inicias la siguiente tarea con un nuevo ciclo Explore → Plan → Code. El context window acumula la sesión anterior, lo que ayuda a Claude a mantener coherencia.

Este flujo — Explore, Plan, Code, Verify, Commit — se repite durante toda la sesión. Es la unidad de trabajo con Claude Code.

Versiones y compatibilidad

Este módulo cubre:

  • Claude Code 2.0+
  • Opus 5 (1M token context window)
  • Sonnet 5 (1M token context window)
  • Haiku 4.5 (200K context window)

Features cubiertos:

  • ✅ Explore mode (subagent built-in)
  • ✅ Plan mode (comando /plan o Shift+Tab)
  • ✅ Agent mode (modo por defecto)
  • ✅ Auto mode (permission classifier — research preview, marzo 2026)
  • ✅ Effort level (low, medium, high, xhigh, max — funciona en Opus 5 y Sonnet 5; xhigh solo Opus 5)
  • ✅ Compaction automática + hooks PreCompact / PostCompact
  • ✅ Session recap al resumir sesiones (--resume, --continue)
  • ✅ Multi-turn conversations

Nota sobre cambios:

Claude Code se actualiza aproximadamente cada 2 días (~35 releases en 7 semanas, enero-febrero 2026). Los conceptos y el workflow que enseñamos son estables — los modos Explore, Plan y Code son fundamentales a la arquitectura de Claude Code. Los detalles de UI pueden cambiar; los principios no.

Resumen

Este módulo es el corazón operativo de la guía. Pasamos de "configurar Claude Code" a "trabajar con Claude Code."

Lo que aprendiste en esta cápsula:

  • Claude Code no es un chatbot — es un agente con un workflow definido
  • El ciclo Explore → Plan → Code es cómo trabajan los profesionales
  • Hay 3 modos: Explore (read-only), Plan (diseño), Agent/Code (ejecución)
  • Multi-turn conversations son la norma, no la excepción
  • El context window es finito y debes gestionarlo
  • /effort controla la profundidad de razonamiento

Siguiente cápsula: 02 - Explore, Plan y Code — los tres modos en profundidad, con ejemplos prácticos y ejercicios.

Recursos adicionales

Documentación oficial

Subagents y modos

  • Sub-agents — Documentación de subagents built-in (Explore, Plan)
  • CLI Reference — Todos los comandos y flags disponibles

Contexto y memoria

  • Memory — Sistema de memoria y CLAUDE.md
  • Settings — Configuración de scopes y preferences
← AnteriorCLAUDE.local.md y User CLAUDE.md: Preferencias Personales Sin Afectar al EquipoSiguiente →Explore, Plan y Code: Los tres modos de Claude Code