Módulo 2: Agentic Research con Explore Subagent

Descripción de la capsula

Vas a conocer la herramienta que cambia como investigas codebases: el Explore subagent de Claude Code. En el módulo anterior aprendiste un método sistematico para hacer onboarding — las 5 preguntas, la exploracion ordenada, la documentación. Ese método funciona con Claude Code directamente. Pero Claude Code general puede leer, escribir, y ejecutar. Eso significa que cada vez que exploras, existe la posibilidad — por remota que sea — de que un prompt mal redactado modifique algo. Explore elimina esa posibilidad por completo.

Explore es un subagent que opera en modo read-only. No puede modificar archivos, no puede ejecutar comandos destructivos, no puede escribir código. Solo puede leer, buscar, y responder preguntas. Esa restriccion suena como una limitacion, pero es exactamente lo contrario: es un safety net que te da confianza total para investigar. Puedes hacer las preguntas mas agresivas sobre un codebase de producción sin riesgo. Puedes explorar modulos que no entiendes sin miedo a romper algo. Puedes dejar que el agente navegue libremente porque sabes que lo peor que puede hacer es leer.

Este módulo te ensena a dominar Explore como herramienta de investigacion dedicada. Vas a aprender cuando usarlo (investigar) vs cuando usar Claude Code general (modificar). Vas a experimentar la diferencia entre busqueda por texto (grep) y busqueda por significado (semantica). Y vas a practicar tres patrones de exploracion — top-down, dependency-following, y feature-tracing — que convierten preguntas vagas en respuestas precisas.

Contexto del Módulo

Donde estamos?

Esta es la Guia #8 del Claude Code Agentic Development Path — "Refactoring & Legacy Code with Claude Code." Estas en el Módulo 2 de 8, dentro de la Phase 1: Entender Codebases.

Lo que construiste en el Módulo 1:

Skill	Lo que aprendiste
Método de onboarding	Las 5 preguntas iniciales: estructura, entry points, data flow, patterns, tech debt
Claude Code como reader	Usar Claude Code para analizar código existente, no solo para generar
Mental model	Construir un mapa mental del codebase en 3 niveles de profundidad
Documentación	Producir un onboarding doc tangible que otros pueden usar
Validación	Hacer un cambio pequeno para confirmar tu comprension

El Módulo 1 te dio el método — que preguntar y en que orden. El Módulo 2 te da la herramienta especializada — un agente disenado exclusivamente para investigacion. Es como la diferencia entre usar un cuchillo de cocina generico (funciona para todo) y un bisturi (disenado para precision). Ambos cortan, pero el bisturi esta optimizado para una tarea especifica.

Hacia donde vamos?

La Phase 1 completa tiene 3 modulos, cada uno anadiendo una capa de profundidad en la comprension de codebases:

Phase 1: Entender Codebases (Modulos 1-3)
+-- Modulo 1: Onboarding con AI — 5-10x Mas Rapido       [COMPLETADO]
+-- Modulo 2: Agentic Research con Explore Subagent       <-- ESTAS AQUI
+-- Modulo 3: Entender Arquitectura Existente

Phase 2: Refactoring (Modulos 4-6)
+-- Modulo 4: Refactoring Multi-File Coordinado
+-- Modulo 5: Migracion de Frameworks y Lenguajes
+-- Modulo 6: Context Management para Proyectos Grandes

Phase 3: Legacy y Proyecto (Modulos 7-8)
+-- Modulo 7: Modernizar Legacy Code
+-- Modulo 8: Proyecto Integrador — Migracion Completa

La progresion dentro de Phase 1:

Modulo 1: Metodo general de onboarding (completado)
    |     (5 preguntas, exploracion sistematica, documentar hallazgos)
    v
Modulo 2: Herramienta especializada — Explore subagent (aqui)
    |     (read-only, busqueda semantica, patrones de exploracion)
    v
Modulo 3: Analisis arquitectural profundo
          (dependency maps, flow analysis, pattern identification)

Después de este módulo, el Módulo 3 toma tus hallazgos de exploracion y los convierte en representaciones visuales y documentadas: dependency maps que muestran que depende de que, diagramas de arquitectura que mapean layers y components, y flow analysis que traza el camino de los datos.

Por que este módulo importa?

El problema que resuelve

El Módulo 1 te enseno a explorar con Claude Code directamente. Funciona bien. Pero tiene una tension inherente: Claude Code general puede hacer de todo — leer, escribir, ejecutar, modificar. Cuando le pides "explicame como funciona el módulo de pagos," puede decidir que para explicartelo necesita ejecutar algo, o modificar algo para probarlo. No es comun, pero es posible.

Esa posibilidad genera una ansiedad sutil pero real:

Developer pensando mientras explora:
"Quiero entender este codebase, pero..."
- "Y si le pido algo y modifica un archivo sin que me de cuenta?"
- "Y si ejecuta un comando destructivo mientras busca informacion?"
- "No quiero tocar nada hasta que entienda como funciona"
- "Deberia crear un branch de seguridad antes de explorar?"

Explore elimina esa ansiedad completamente. Es read-only por diseno — no por politica, no por convencion, sino por restriccion tecnica. No puede modificar nada aunque quiera. Puedes entregarle las llaves de tu codebase de producción y lo peor que puede hacer es leer archivos.

La diferencia entre investigar y modificar

En el workflow profesional de un developer, hay dos fases distintas:

Fase	Objetivo	Herramienta ideal	Riesgo
Investigacion	Entender que hace el código, como funciona, donde estan los problemas	Explore subagent	Cero (read-only)
Modificacion	Cambiar código, refactorizar, migrar, corregir bugs	Claude Code general	Controlado (escribe archivos)

La mayoria de developers mezcla ambas fases. Investigan un poco, modifican un poco, investigan mas, modifican mas. El resultado: cambios hechos sin comprension completa, bugs por no entender efectos secundarios, y horas de debugging que se habrian evitado con 15 minutos mas de investigacion.

Explore te fuerza a separar las fases. Investiga primero — todo lo que necesites, sin limite, sin riesgo. Cuando tengas comprension completa, cambia a Claude Code general y modifica con confianza.

Read-only es una feature

Algunos developers ven la restriccion de read-only como una limitacion. "Si no puede modificar nada, para que sirve?" Es la misma lógica que pregunta "si un microscopio no puede operar, para que sirve?" La respuesta: porque ver con precision es prerequisito de actuar con precision.

Beneficios concretos de read-only:

✅ Confianza total. Puedes explorar sin crear un branch de seguridad.
✅ Exploracion sin ansiedad. No hay "y si algo sale mal."
✅ Investigacion en producción. Puedes usar Explore directamente en tu codebase de producción.
✅ Delegacion segura. Puedes dejar que Explore navegue autonomamente por el codebase.
✅ Foco en comprension. Sin la opción de modificar, toda tu atencion esta en entender.

Busqueda semantica: el diferenciador

Explore no solo lee archivos — entiende significado. La diferencia con grep es fundamental:

# Con grep: buscas texto
grep -r "validate" src/
# Resultado: archivos que contienen la palabra "validate"
# Si la funcion se llama check_params, NO la encuentras

# Con Explore: buscas significado
"Donde se validan los inputs del usuario?"
# Resultado: encuentra check_params, sanitize_input, ensure_valid
# Porque entiende que esas funciones VALIDAN aunque no digan "validate"

Esta diferencia es especialmente poderosa en codebases legacy donde los nombres no siempre reflejan la función real. Funciones con nombres historicos, abreviaciones crípticas, o convenciones de otro equipo — Explore las encuentra por lo que hacen, no por como se llaman.

La Evolucion del Agentic Research

De grep a busqueda semantica

La forma en que buscamos código ha evolucionado dramaticamente:

1990s: grep (busqueda de texto literal)
    "Encuentra esta cadena exacta en estos archivos"

2000s: IDE search (busqueda + contexto basico)
    "Encuentra esta cadena y muestrame el archivo"

2010s: ctags/LSP (busqueda de simbolos)
    "Encuentra donde se define/usa esta funcion"

2020s: GitHub Code Search (busqueda indexada)
    "Encuentra este patron en millones de repos"

2025-26: AI-powered search (busqueda semantica)
    "Encuentra donde se MANEJA AUTENTICACION 
     sin saber el nombre de la funcion"

Cada paso fue un salto en productividad. De buscar texto exacto a buscar significado. Explore representa el último paso: preguntas en lenguaje natural, respuestas que entienden contexto e intencion.

Como Claude Code spawns el Explore subagent

Cuando le pides a Claude Code que investigue algo en modo Explore, internamente ocurre lo siguiente:

Tu prompt: "Usa Explore para entender como funciona el sistema de pagos"

Claude Code:
1. Spawns un subagent en modo read-only
2. El subagent tiene acceso al file system (solo lectura)
3. El subagent puede:
   - Leer archivos
   - Buscar en archivos (grep, find)
   - Navegar la estructura de directorios
   - Analizar contenido de archivos
4. El subagent NO puede:
   - Escribir archivos
   - Ejecutar codigo
   - Instalar paquetes
   - Modificar configuracion
5. El subagent reporta hallazgos a Claude Code
6. Claude Code te presenta los resultados

No necesitas entender los detalles internos para usar Explore efectivamente. Lo que importa es el resultado: un agente de investigacion con todas las capacidades de lectura y ninguna capacidad de escritura.

Cuando usar Explore vs Claude Code general

La decisión es simple:

Si tu objetivo es ENTENDER -> usa Explore
Si tu objetivo es CAMBIAR  -> usa Claude Code general

Reglas practicas:

Situacion	Herramienta	Razon
Explorar un codebase nuevo	Explore	Investigacion pura, cero riesgo
Entender como funciona un feature	Explore	Busqueda semantica + read-only
Encontrar donde se usa una función	Explore	Navegacion de código
Diagnosticar un bug (investigar)	Explore	Investigacion sin riesgo
Arreglar un bug (modificar)	Claude Code general	Necesitas escribir
Refactorizar código	Claude Code general	Necesitas escribir
Escribir tests	Claude Code general	Necesitas escribir
Evaluar tech debt	Explore	Análisis read-only
Documentar un módulo	Explore (investigar) + Claude Code (escribir)	Combinacion de ambos

El pattern mas productivo es: Explore primero, Claude Code general después. Investiga todo lo que necesites con Explore, forma tu plan, y luego ejecuta con Claude Code general.

Autodiagnostico: Donde Estas Hoy?

Antes de avanzar, evalua tu relacion actual con la busqueda de código.

Test rápido de 5 preguntas

1. Cuando necesitas encontrar "donde se maneja la autenticación" en un codebase desconocido, que haces?

(a) grep -r "auth" src/ y reviso los resultados
(b) Busco archivos con nombres como auth.py, login.py, security.py
(c) Le pregunto a un companero
(d) Le pregunto a Claude Code directamente

2. Que tan comodo te sientes explorando un codebase de producción?

(a) Muy comodo — no me preocupa romper nada explorando
(b) Algo incomodo — siempre creo un branch antes
(c) Incomodo — prefiero que alguien me explique
(d) Nunca lo hago directamente — solo leo documentación

3. Conoces la diferencia entre busqueda por texto y busqueda semantica?

(a) Si, y uso busqueda semantica regularmente
(b) He oido de busqueda semantica pero no la uso
(c) No estoy seguro de la diferencia
(d) No, son lo mismo para mi

4. Cuando exploras un codebase, sigues algun patron de exploracion?

(a) Si — empiezo por entry points y sigo el flujo
(b) Mas o menos — tengo una secuencia general
(c) No — voy de archivo en archivo según necesidad
(d) No — abro archivos al azar hasta que entiendo

5. Has usado herramientas AI especificas para investigacion de código (no escritura)?

(a) Si, regularmente
(b) Ocasionalmente
(c) Lo he intentado pero no sistematicamente
(d) No, solo uso AI para generar código

Interpretacion

Mayoria de (a): Tienes buena base. Este módulo te dara una herramienta especializada que potencia lo que ya haces.
Mayoria de (b): Tienes intuicion correcta. Explore formalizara tu proceso y lo hara mas eficiente.
Mayoria de (c) o (d): Vas a experimentar un cambio significativo. Explore te dara superpoderes de investigacion que no tenias.

No importa donde estes — Explore es una herramienta nueva para la mayoria de developers, y dominarla es una ventaja competitiva directa.

Vocabulario Clave

Terminos que usaras a lo largo de todo el módulo:

Termino	Definición
Explore subagent	Un subagent de Claude Code que opera en modo read-only, disenado especificamente para investigacion de codebases
Read-only mode	Restriccion tecnica que impide cualquier operación de escritura — solo lectura de archivos y navegacion
Busqueda semantica	Encontrar código por significado e intencion, no por texto exacto. "Donde se validan inputs?" encuentra funciones que validan aunque se llamen check_params
Busqueda por texto	Buscar una cadena exacta (grep, Ctrl+F). Solo encuentra coincidencias literales
Top-down exploration	Patron de exploracion que empieza por el entry point y baja hacia los detalles, nivel por nivel
Dependency-following	Patron de exploracion que sigue imports y llamadas de funciones de un módulo a otro
Feature-tracing	Patron de exploracion que rastrea un feature completo de punta a punta — desde el request hasta la respuesta
Subagent	Un agente subordinado que Claude Code spawns internamente para realizar tareas especificas
Agentic research	Investigacion de código donde un agente AI navega autonomamente el codebase buscando respuestas

Estos terminos se reforzaran con practica en las capsulas siguientes. No necesitas memorizarlos ahora — los iras internalizando a medida que los uses.

Objetivo Profesional

Al final de este módulo podras:

Invocar y usar el Explore subagent para investigacion read-only de codebases, sabiendo exactamente cuando es la herramienta correcta y cuando debes usar Claude Code general.
Aplicar busqueda semantica para encontrar código por significado e intencion — "donde se maneja la autenticación" — en lugar de depender exclusivamente de busqueda por texto exacto.
Diferenciar busqueda semantica vs grep y saber cuando usar cada una: grep para texto exacto conocido, busqueda semantica para conceptos y funcionalidades.
Usar 3 patrones de exploracion: top-down (de entry point hacia profundidad), dependency-following (seguir imports y llamadas entre modulos), y feature-tracing (rastrear un feature end-to-end desde request hasta response).
Combinar multiples queries de Explore para construir una vision completa de un codebase, conectando hallazgos parciales en un mapa coherente.
Separar investigacion de modificacion como principio de trabajo: Explore primero (entender), Claude Code general después (cambiar).

El cambio de perspectiva

Entras a este módulo sabiendo explorar con Claude Code general — una herramienta poderosa pero generica. Sales sabiendo que para investigacion existe una herramienta especializada que elimina riesgo, optimiza la busqueda, y te da confianza total. El insight central: la restriccion de read-only es una feature que te hace mas productivo, no menos.

Por que esto importa en tu carrera

La investigacion de código es una actividad diaria que la mayoria de developers hace de forma ineficiente:

Junior: Necesita entender modulos que otros escribieron para contribuir al equipo
Mid-level: Investiga bugs en código ajeno, necesita encontrar la causa raiz rápido
Senior: Revisa PRs de otros, evalua impacto de cambios en areas que no domina
Tech Lead: Evalua arquitectura, identifica riesgos tecnicos, toma decisiones informadas
Consultant: Investiga codebases desconocidos constantemente, la velocidad es ingreso

En todos los casos, la calidad de tu investigacion determina la calidad de tus decisiones. Explore te da investigacion de alta calidad sin riesgo.

Progresion del Módulo

Mapa del Módulo

Capsula	Tema	Que aprenderas
02	Explore Subagent — Investigacion Read-Only	Que es Explore, como invocarlo, cuando usarlo. Read-only como feature. Demos practicas con Claude Code CLI
03	Busqueda Semantica vs Grep — Encontrar por Significado	Diferencia entre buscar texto y buscar significado. Cuando usar grep vs Explore. Ejemplos progresivos
04	Patrones de Exploracion — Top-Down, Dependency-Following, Feature-Tracing	3 patrones sistematicos para investigar codebases. Cuando usar cada uno. Combinarlos para vision completa
05	Proyecto: Exploracion de Codebase con Explore	Explorar un codebase mediano respondiendo preguntas especificas usando solo Explore. Documentar hallazgos

Flujo de aprendizaje

Capsula 02: La Herramienta        Capsula 03: El Diferenciador
(que es Explore, como usarlo) ->  (semantica vs grep, cuando cada uno)
        |                                  |
        v                                  v
Capsula 04: Los Patrones          Capsula 05: El Proyecto
(3 formas de explorar)       ->   (todo junto en un codebase real)

Cada capsula construye sobre la anterior. La capsula 02 establece la herramienta — que es, como funciona, por que read-only es una ventaja. La capsula 03 profundiza en el diferenciador clave: la busqueda semantica. La capsula 04 te da 3 patrones sistematicos para investigar. La capsula 05 integra todo en un proyecto real.

La narrativa del módulo

Primero vas a entender que es Explore y por que su restriccion de read-only es una feature, no una limitacion (capsula 02). Vas a ver demos practicas de Explore en acción y comparar su comportamiento con Claude Code general. Después aprenderas la diferencia entre buscar texto y buscar significado — el poder real de Explore — con ejemplos que demuestran por que grep no es suficiente para investigacion seria (capsula 03). Con la herramienta y el diferenciador claros, aprenderas 3 patrones de exploracion que convierten preguntas vagas en investigaciones sistematicas (capsula 04). Finalmente, integras todo en un proyecto donde exploras un codebase real usando solo Explore (capsula 05).

La progresion es intencional: no puedes aplicar patrones sin entender la herramienta, no puedes apreciar la herramienta sin entender su diferenciador (busqueda semantica), y no puedes consolidar sin practica real.

Conexión con Proyecto

Mini-proyecto del módulo: Exploracion de Codebase con Explore

En la capsula 05 vas a tomar un codebase mediano y responder una serie de preguntas especificas usando solo Explore. No vas a modificar nada — solo investigar. Las preguntas son concretas y requieren investigacion real:

"Como fluye un request de login desde el endpoint hasta la base de datos?"
"Que dependencias tiene el módulo de pagos?"
"Donde se validan los inputs del usuario?"
"Que patterns de diseno se usan y en que modulos?"
"Donde esta el tech debt mas critico?"

El foco no es el conocimiento del codebase — es la eficiencia y profundidad de la investigacion.

Lo que entregaras:

✅ Respuestas documentadas a cada pregunta con el proceso de exploracion
✅ Comparacion: prompts usados, hallazgos, y como conectas la información
✅ Análisis de cuando usaste busqueda semantica vs cuando habrias necesitado grep
✅ Reflexion sobre que patron de exploracion usaste para cada pregunta

Conexión con el proyecto integrador de la guia (Módulo 8)

El Módulo 8 es una Migracion Completa de Proyecto Legacy. La investigacion con Explore que aprendes aquí es la base de la fase de análisis de esa migracion. Antes de migrar, necesitas entender: que dependencias hay, como fluyen los datos, donde estan los riesgos. Explore es tu herramienta para esa fase.

Modulo 1: Onboarding -> entender el codebase (metodo)         -+
Modulo 2: Explore -> investigar en profundidad (herramienta)    |
Modulo 3: Arquitectura -> mapear dependencias y patterns        | Alimentan el
Modulo 4: Refactoring -> cambios coordinados                    +- Proyecto
Modulo 5: Migracion -> cambio de framework                      | Integrador
Modulo 6: Context -> manejar proyectos grandes                  | (Modulo 8)
Modulo 7: Legacy -> modernizar codigo viejo                    -+

Conexión con el Módulo 3

La conexión directa es con el Módulo 3 (Entender Arquitectura Existente). Los hallazgos que obtienes con Explore en este módulo se convierten en representaciones formales en el Módulo 3:

Lo que produces con Explore (M2)	Lo que produces en Architecture (M3)
"El módulo de pagos depende de users y products"	Dependency map formal con grafos
"Un request de login pasa por auth -> users -> db"	Flow diagram con mermaid
"El proyecto usa service layer + repository pattern"	Architecture diagram por layers
"Hay circular dependency entre orders y inventory"	Anti-pattern documentation

Explore te da los hallazgos. Architecture te da la forma de representarlos.

Limites: Que NO Se Hara

Para mantener el foco:

❌ No vas a modificar código. Este módulo es 100% investigacion. Modificar viene en los modulos 4-7.
❌ No vas a generar dependency maps ni diagramas formales. Eso es el Módulo 3. Aquí investigas; en el Módulo 3 representas visualmente.
❌ No vas a configurar Explore de forma avanzada. Usas Explore con su configuración default. Customization avanzada esta fuera del scope.
❌ No vas a trabajar con codebases extremadamente grandes (100K+ lineas). Context management viene en el Módulo 6.
❌ No vas a comparar Explore con herramientas externas (GitHub Copilot search, Sourcegraph). El foco es dominar Explore, no evaluar alternativas.
❌ No vas a cubrir busqueda de archivos no-código (imagenes, configs binarias). El scope es código Python.

Lo que si cubrimos a profundidad:

✅ Explore subagent como herramienta de investigacion read-only
✅ Busqueda semantica vs grep — cuando usar cada una
✅ 3 patrones de exploracion: top-down, dependency-following, feature-tracing
✅ Combinar multiples queries para vision completa
✅ Explore vs Claude Code general: cuando cada uno
✅ Investigar antes de modificar como principio profesional

Evidencia de Exito

Al terminar el módulo, estos son los criterios medibles que demuestran que lo completaste con exito:

Criterios obligatorios:

Criterio	Como verificarlo
Puedes invocar Explore y usarlo para investigar un codebase	Abres un proyecto desconocido y respondes 3 preguntas usando solo Explore
Entiendes la diferencia entre busqueda semantica y grep	Puedes dar un ejemplo donde grep falla y Explore encuentra el resultado
Aplicas los 3 patrones de exploracion	Puedes elegir el patron correcto para una pregunta dada y justificar tu eleccion
Combinas hallazgos de multiples queries	Tu investigacion conecta información de diferentes partes del codebase en una narrativa coherente
Separas investigacion de modificacion	Tu workflow es: Explore primero (entender), Claude Code general después (cambiar)

Criterios de excelencia (opcionales):

✅ Tu investigacion descubre algo que no era obvio desde la documentación del proyecto
✅ Puedes explicar a otro developer el codebase basandote solo en lo que encontraste con Explore
✅ Identifies un patron de exploracion que es mas natural para tu forma de pensar y lo articulas

Como se ve el exito en la practica

Antes de este módulo:

Pregunta: "Donde se validan los inputs?"
-> grep -r "valid" src/ -> 47 resultados -> revisar uno por uno
-> 20 minutos despues: encontraste 3 funciones pero no estas seguro
   si hay mas. check_params() no aparecio porque no tiene "valid" en el nombre.

Después de este módulo:

Pregunta: "Donde se validan los inputs?"
-> Explore: "Donde se validan los inputs del usuario en este proyecto?"
-> 30 segundos: Explore identifica check_params(), sanitize_input(),
   ensure_valid(), y el middleware de validacion global en api/deps.py
-> Vision completa, sin importar como se llamen las funciones

La diferencia no es solo velocidad — es completitud. Explore encuentra lo que grep no puede porque busca por significado, no por texto.

La pregunta de validación final:

Si alguien te da un codebase de 10K lineas con preguntas especificas — "como maneja autenticación?", "que dependencias tiene el módulo X?", "donde se procesan pagos?" — puedes responder todas usando Explore en menos de 30 minutos?

Si la respuesta es si, completaste este módulo con exito.

Prerequisites del Módulo

Conocimiento requerido:

✅ Módulo 1 completado: el método de las 5 preguntas y la exploracion sistematica
✅ Claude Code básico: saber invocar Claude Code, hacer prompts, trabajar en terminal
✅ Python intermedio: leer código Python sin dificultad
✅ Git básico: clonar repos, navegar entre archivos

No necesitas:

❌ Experiencia previa con Explore — se ensena desde cero
❌ Conocimiento de busqueda semantica — se explica en la capsula 03
❌ Un codebase propio — usaras proyectos open-source
❌ Experiencia con herramientas de análisis estatico

Setup técnico:

Herramienta	Para que
Claude Code instalado y actualizado	Explore subagent requiere versión reciente
Terminal con acceso a Git	Clonar repos para explorar
Conexión a internet	Clonar proyectos open-source
Editor de texto	Documentar hallazgos

Verificacion rapida de setup

# Verifica Claude Code
claude --version
# Esperado: version reciente (2025+)

# Verifica que puedes invocar Explore
claude "Usa Explore para listar los archivos Python en el directorio actual"
# Esperado: respuesta con lista de archivos

# Verifica Git
git --version
# Esperado: git 2.0+

# Clona un proyecto de prueba
git clone --depth 1 https://github.com/encode/httpx /tmp/httpx-explore-test
# Esperado: clona sin errores

Si algo no funciona, revisa tu instalacion de Claude Code antes de continuar.

El Principio Central

Investigar antes de modificar

Este principio del Módulo 1 se profundiza aquí. No solo "investiga antes de modificar" — ahora tienes la herramienta correcta para hacerlo:

Explore es tu primer paso en cualquier codebase desconocido. Investiga sin riesgo, entiende con profundidad, y solo entonces modifica con confianza.

El workflow profesional que este módulo establece:

Paso 1: Explore (investigar)
    - Que hace este codebase?
    - Como fluyen los datos?
    - Donde estan los riesgos?
    
Paso 2: Analizar (pensar)
    - Que necesito cambiar?
    - Que puede romper el cambio?
    - Cual es la estrategia mas segura?
    
Paso 3: Claude Code general (modificar)
    - Ejecutar el cambio con comprension completa
    - Verificar con tests
    - Documentar

La fase 1 (Explore) es donde se gana o se pierde la partida. Una investigacion superficial produce cambios peligrosos. Una investigacion profunda produce cambios seguros.

Preguntas especificas producen respuestas utiles

El Módulo 1 establecio que "explorar sin propósito" no funciona. Este módulo refuerza el principio con Explore:

Malo:  "Explore, mira este codebase"
       -> Resultado vago, sin foco, informacion dispersa

Bueno: "Explore, como fluye un request de /api/users 
        desde el endpoint hasta la respuesta?"
       -> Resultado preciso: handler -> service -> repository -> DB -> response

Cada sesión de Explore debe empezar con una pregunta especifica. La pregunta define la calidad de la investigacion.

Lo Que Viene Después de Este Módulo

Módulo 3: Entender Arquitectura Existente

La transicion directa: "Ya puedes investigar cualquier aspecto de un codebase con Explore — encontrar funciones, trazar flujos, identificar dependencias. Ahora aprende a convertir esos hallazgos en representaciones formales que puedas compartir con tu equipo."

El Módulo 3 te ensena a producir:

Dependency maps: Grafos que muestran que módulo depende de que. Generados por Claude Code como mermaid o ASCII.
Flow diagrams: Diagramas que trazan el camino de un request desde el entry point hasta la respuesta.
Architecture diagrams: Representaciones de layers, components, e interfaces del sistema.
Pattern identification: Reconocimiento formal de MVC, service layer, repository pattern, y otros.
Anti-pattern detection: Identificacion de circular dependencies, god objects, spaghetti code.

La progresion de Phase 1 completa:

Modulo 1: "Se como explorar un codebase" (metodo)
    |
    v
Modulo 2: "Puedo investigar en profundidad con seguridad" (herramienta)
    |
    v
Modulo 3: "Puedo visualizar y comunicar la arquitectura" (representacion)

Cada módulo te da un nivel mas profundo. Al terminar Phase 1, no solo entiendes un codebase — puedes crear un mapa completo, verificable, y compartible.

Distribucion de Tiempo Estimada

Capsula	Tiempo estimado	Actividad principal
01 (esta)	10-15 min	Lectura: objetivos y contexto del módulo
02	20-25 min	Lectura + demos: Explore subagent en acción
03	20-25 min	Lectura + ejercicios: busqueda semantica vs grep
04	20-25 min	Lectura + ejercicios: 3 patrones de exploracion
05	30-45 min	Proyecto: exploracion de codebase con Explore
Total	~1.75-2.25 hrs

El módulo esta disenado para completarse en una sesión. Si necesitas dividirlo, el punto natural de pausa es después de la capsula 03 (busqueda semantica vs grep).

Resumen

✅ Este módulo introduce el Explore subagent — herramienta de investigacion read-only de Claude Code
✅ Read-only es una feature, no una limitacion: da confianza total para investigar sin riesgo
✅ La busqueda semantica encuentra código por significado, no por texto — el diferenciador clave de Explore
✅ 3 patrones de exploracion: top-down, dependency-following, feature-tracing
✅ El principio reforzado: investigar antes de modificar, con la herramienta correcta
✅ Explore primero (entender), Claude Code general después (cambiar)
✅ El proyecto del módulo: explorar un codebase respondiendo preguntas especificas usando solo Explore
✅ Conecta directamente con el Módulo 3: los hallazgos de Explore se convierten en arquitectura visual

Recursos Adicionales

Claude Code Documentation — Explore Subagent — Documentación oficial sobre el Explore subagent y sus capacidades.
Agentic Research Patterns — Anthropic — Como los agentes AI realizan investigacion autonoma de codebases.
Working Effectively with Legacy Code — Michael Feathers — El principio de entender antes de modificar aplicado a código legacy.
Semantic Code Search — GitHub Blog — Como evoluciono la busqueda de código de texto a semantica.
The Art of Reading Code — Felienne Hermans — Tecnicas para leer y entender código de otros, complementario al approach con AI.
Code as a Crime Scene — Adam Tornhill — Investigacion de codebases usando datos historicos y patrones de comportamiento.

Siguiente capsula: Explore Subagent — Investigacion Read-Only — que es, como invocarlo, y por que el modo read-only te hace mas productivo.

Módulo 2, Capsula 01 — Refactoring & Legacy Code with Claude Code Guide

← AnteriorProyecto del Módulo: Onboarding a Codebase Open-Source Siguiente →Explore Subagent — Investigacion Read-Only