Explore Subagent — Investigacion Read-Only

Descripción de la capsula

Vas a aprender a usar el Explore subagent de Claude Code desde cero. No vas a leer teoria sobre lo que "podria hacer" — vas a verlo en acción con demos concretas que puedes replicar en tu terminal. Explore es el primer subagent de Claude Code que deberias dominar porque es el mas seguro: no puede modificar nada. Y esa seguridad te da la libertad de investigar sin restricciones.

Esta capsula responde tres preguntas fundamentales: que es Explore (un subagent read-only para investigacion), como lo invocas (prompts especificos con la palabra "Explore"), y cuando lo usas en lugar de Claude Code general (cuando el objetivo es entender, no cambiar). Cada respuesta viene con demostraciones practicas que puedes ejecutar inmediatamente.

La conexión con el proyecto es directa: en la capsula 05 vas a usar Explore para investigar un codebase completo respondiendo preguntas especificas. Esta capsula te da el dominio de la herramienta que necesitas para ese proyecto.

Que es el Explore Subagent

El concepto en 30 segundos

Explore es un subagent que Claude Code puede invocar internamente para investigar codebases. La diferencia con Claude Code general es una sola pero fundamental: Explore opera en modo read-only. Puede leer cualquier archivo, buscar en cualquier directorio, navegar toda la estructura del proyecto — pero no puede escribir, ejecutar, ni modificar nada.

La arquitectura simple

Tu (developer)
    |
    v
Claude Code (agente principal)
    |
    +-- Explore subagent (read-only)
    |     - Lee archivos
    |     - Busca en directorios
    |     - Analiza contenido
    |     - Responde preguntas
    |     - NO escribe
    |     - NO ejecuta
    |     - NO modifica
    |
    +-- Otros subagents (con permisos especificos)

Cuando le pides a Claude Code que use Explore, internamente spawns un agente con permisos restringidos a solo lectura. Ese agente navega tu codebase autonomamente — abriendo archivos, siguiendo imports, leyendo funciones — hasta que tiene la información que necesita para responder tu pregunta.

Que puede hacer Explore

Que NO puede hacer Explore

Estas restricciones no son bugs — son features. Cada una te da una garantia:

• ✅ Tus archivos estan intactos después de la exploracion
• ✅ Ningun proceso se ejecuto sin tu conocimiento
• ✅ Ninguna dependencia se instalo o modifico
• ✅ Tu git history no cambio
• ✅ Tu entorno de desarrollo esta exactamente como lo dejaste

Como Invocar Explore

Método 1: Invocacion directa en Claude Code CLI

La forma mas simple de usar Explore es pedirle a Claude Code que lo use:

claude

> Usa Explore para investigar como este proyecto maneja la autenticacion.

Output esperado:

Voy a usar el Explore subagent para investigar el sistema de 
autenticacion de este proyecto.

[Explore subagent activado - modo read-only]

Hallazgos de la investigacion:

1. **Entry point de autenticacion:** src/api/v1/auth.py
   - POST /auth/login -> login() recibe email y password
   - POST /auth/register -> register() crea nuevo usuario
   - POST /auth/refresh -> refresh_token() renueva JWT

2. **Flujo de autenticacion:**
   login() -> AuthService.authenticate()
           -> UserRepository.get_by_email()
           -> PasswordHasher.verify()
           -> TokenService.create_access_token()
           -> return {access_token, refresh_token}

3. **Middleware de autenticacion:**
   src/core/security.py -> get_current_user()
   - Extrae JWT del header Authorization
   - Decodifica con jose.jwt.decode()
   - Busca usuario en DB
   - Inyecta usuario en endpoint via Depends()

4. **Dependencias:**
   - python-jose (JWT encoding/decoding)
   - passlib (password hashing con bcrypt)
   - Secret key en src/core/config.py -> Settings.SECRET_KEY

No se modifico ningun archivo durante esta investigacion.

Método 2: Prompt contextualizado

Puedes darle mas contexto a Explore para guiar su investigacion:

> Usa Explore para responder esta pregunta especifica: 
  Cuando un usuario hace POST /api/v1/orders, que pasa step by step 
  desde que llega el request hasta que se guarda en la base de datos?

Output esperado:

[Explore subagent - investigando flujo de POST /api/v1/orders]

Flujo completo step-by-step:

1. Request llega a src/api/v1/orders.py -> create_order()
   - Depends(get_current_user) verifica JWT
   - Depends(get_db) inyecta session de DB
   - Body se valida contra OrderCreate schema (src/schemas/order.py)

2. create_order() llama a OrderService.create()
   (src/services/order_service.py linea 45)
   - Verifica que el usuario existe
   - Verifica que los productos existen y tienen stock
   - Calcula el total con descuentos

3. OrderService.create() llama a OrderRepository.create()
   (src/repositories/order_repository.py linea 23)
   - Crea instancia de Order model (src/models/order.py)
   - Crea instancias de OrderItem para cada producto
   - session.add(order) + session.commit()

4. Post-creation hooks:
   - OrderService envia evento a NotificationService
   - NotificationService envia email de confirmacion (async)
   - StockService.decrease_stock() actualiza inventario

5. Response:
   - OrderRepository retorna Order model
   - OrderService convierte a OrderResponse schema
   - create_order() retorna HTTP 201 con order details

Método 3: Exploracion iterativa

Puedes hacer multiples preguntas a Explore en secuencia, donde cada respuesta informa la siguiente:

# Pregunta 1: Vista general
> Usa Explore para darme un overview de los modulos principales 
  de este proyecto y que hace cada uno.

# [Explore responde con lista de modulos]

# Pregunta 2: Profundizar en un modulo especifico
> Ahora usa Explore para profundizar en el modulo de pagos: 
  que servicios usa, que dependencias externas tiene, y que 
  patrones de error maneja.

# [Explore responde con detalles del modulo de pagos]

# Pregunta 3: Seguir una dependencia
> Explore encontro que pagos depende de StripeClient. 
  Usa Explore para investigar StripeClient: donde esta definido, 
  que metodos tiene, y como maneja errores de Stripe.

# [Explore responde con detalles de StripeClient]

Cada pregunta estrecha el foco. Empiezas ancho (todos los modulos), luego profundizas (módulo de pagos), luego sigues una dependencia (StripeClient). Esta es la forma mas productiva de usar Explore.

Demo Practica: Explore en Acción

Demo 1: Primera exploracion de un proyecto desconocido

Vamos a usar un proyecto Python real para demostrar Explore. Primero, el setup:

# Clonar un proyecto de ejemplo
git clone --depth 1 https://github.com/encode/httpx /tmp/httpx-demo
cd /tmp/httpx-demo

# Iniciar Claude Code
claude

Ahora la exploracion:

> Usa Explore para darme un overview completo de este proyecto: 
  estructura, entry points, y que hace cada modulo principal.

Output esperado:

[Explore subagent - investigando httpx]

httpx es un HTTP client para Python que soporta sync y async.

Estructura principal:
httpx/
+-- _api.py           -> Funciones de alto nivel (get, post, put, delete)
+-- _client.py        -> Client y AsyncClient (las clases principales)
+-- _config.py        -> Configuracion (timeouts, limits, SSL)
+-- _content.py       -> Encoding de request body
+-- _decoders.py      -> Decoders de response (gzip, deflate, brotli)
+-- _exceptions.py    -> Jerarquia de excepciones
+-- _models.py        -> Request, Response, URL, Headers, Cookies
+-- _transports/      -> Transporte HTTP real
|   +-- default.py    -> httpcore transport (sync + async)
|   +-- mock.py       -> Mock transport para testing
+-- _urls.py          -> Parsing y manipulacion de URLs

Entry point para usuarios:
- httpx.get(), httpx.post() -> funciones en _api.py
- httpx.Client() -> clase en _client.py (sync)
- httpx.AsyncClient() -> clase en _client.py (async)

Patron principal:
API functions -> Client -> Transport -> httpcore -> socket

Lineas de codigo: ~8,500 (excluyendo tests)

Demo 2: Investigar un flujo específico

> Usa Explore para trazar que pasa exactamente cuando hago 
  httpx.get("https://example.com"). Desde la llamada hasta 
  que recibo la respuesta.

Output esperado:

[Explore subagent - trazando httpx.get()]

Flujo completo de httpx.get("https://example.com"):

1. httpx.get() en _api.py linea 106
   -> Crea un Client() temporal
   -> Llama client.get(url)

2. Client.get() en _client.py linea 780
   -> Llama self.request("GET", url)

3. Client.request() en _client.py linea 815
   -> Construye Request object (_models.py)
   -> Aplica middleware (auth, redirects, cookies)
   -> Llama self._send()

4. Client._send() en _client.py linea 901
   -> Pasa Request al transport layer
   -> transport.handle_request(request)

5. HTTPTransport.handle_request() en _transports/default.py
   -> Delega a httpcore.ConnectionPool
   -> httpcore maneja socket, TLS, HTTP/1.1 o HTTP/2

6. Response vuelve:
   -> httpcore retorna (status, headers, stream)
   -> _client.py construye Response object
   -> Aplica decoders (gzip, etc.)
   -> Retorna Response al usuario

Capas: API -> Client -> Transport -> httpcore -> Network

Demo 3: Busqueda semantica en acción

> Usa Explore para encontrar donde httpx maneja errores de red. 
  No busques la palabra "error" — busca donde se detectan y 
  manejan problemas de conectividad, timeouts, y DNS.

Output esperado:

[Explore subagent - busqueda semantica: manejo de errores de red]

Manejo de errores de red en httpx:

1. **Jerarquia de excepciones** (_exceptions.py):
   HTTPError (base)
   +-- RequestError (problemas al enviar)
   |   +-- TransportError
   |   |   +-- ConnectError      -> fallo de conexion
   |   |   +-- ConnectTimeout    -> timeout al conectar
   |   |   +-- ReadTimeout       -> timeout al leer
   |   |   +-- WriteTimeout      -> timeout al escribir
   |   |   +-- PoolTimeout       -> timeout esperando conexion del pool
   |   +-- DecodingError         -> fallo al decodificar response
   |   +-- TooManyRedirects      -> excedio max redirects
   +-- HTTPStatusError           -> status code >= 400 (con raise_for_status)

2. **Donde se detectan:**
   - ConnectError: _transports/default.py cuando httpcore falla al conectar
   - Timeouts: _config.py define Timeout class, _transports/ los aplica
   - DNS: se propaga desde httpcore como ConnectError

3. **Patron de manejo:**
   - httpcore lanza httpcore.ConnectError
   - _transports/default.py lo captura y re-lanza como httpx.ConnectError
   - El mapping esta en _transports/default.py linea 60-85
   - map_httpcore_exceptions() convierte excepciones httpcore -> httpx

Nota: la busqueda encontro estos archivos sin buscar "error" 
literalmente — analizo el significado del codigo para encontrar 
donde se maneja conectividad y timeouts.

Este ejemplo demuestra el poder de la busqueda semantica. Un grep -r "error" habria retornado cientos de lineas. Explore encontro exactamente los puntos relevantes porque entiende que "manejar errores de red" incluye excepciones de conectividad, timeouts, y DNS.

Explore vs Claude Code General

Comparacion directa

La siguiente tabla resume cuando usar cada herramienta:

El workflow optimo

El workflow profesional que este módulo establece es:

FASE 1: INVESTIGACION (Explore)
+----------------------------------------------+
| "Usa Explore para entender como funciona     |
|  el sistema de pagos"                         |
|                                               |
| Explore lee -> analiza -> responde            |
| Riesgo: CERO                                  |
+----------------------------------------------+
          |
          | (ahora entiendes el sistema)
          v
FASE 2: PLANIFICACION (tu cerebro)
+----------------------------------------------+
| Basado en lo que Explore encontro:            |
| - Necesito cambiar PaymentService.process()   |
| - Debo actualizar el schema de OrderCreate    |
| - Tests existentes cubren el happy path       |
| - Necesito agregar test para edge case        |
+----------------------------------------------+
          |
          | (ahora tienes un plan)
          v
FASE 3: IMPLEMENTACION (Claude Code general)
+----------------------------------------------+
| "Modifica PaymentService.process() para       |
|  agregar soporte de descuentos por volumen"   |
|                                               |
| Claude Code lee + escribe + ejecuta tests     |
| Riesgo: controlado (review antes de commit)   |
+----------------------------------------------+

Ejemplo: la misma tarea con ambas herramientas

Tarea: Entender y modificar el sistema de validación de inputs.

Sin Explore (solo Claude Code general):

> Explicame como funciona la validacion de inputs y luego 
  agrega validacion de email.

# Claude Code hace ambas cosas a la vez:
# 1. Lee archivos para entender
# 2. Modifica archivos para agregar validacion
# 
# Problema: la comprension fue superficial porque el foco
# se dividio entre entender y modificar.
# Resultado: el cambio funciona pero no considero que hay
# un middleware global de validacion en deps.py que tambien
# deberia actualizarse.

Con Explore + Claude Code general (separados):

# Paso 1: Investigar con Explore
> Usa Explore para encontrar TODOS los puntos donde se validan 
  inputs en este proyecto. Incluye middleware, schemas, funciones 
  de validacion custom, y cualquier otro mecanismo.

# Explore investiga y reporta:
# - Pydantic schemas en src/schemas/ (validacion de estructura)
# - Middleware global en src/api/deps.py (validacion de auth)
# - Funciones custom en src/utils/validators.py (validacion de negocio)
# - Decoradores en src/core/validation.py (rate limiting + sanitization)

# Paso 2: Planificar con comprension completa
# Ahora sabes que hay 4 capas de validacion.
# Para agregar validacion de email, necesitas:
# 1. Schema en src/schemas/user.py (Pydantic validator)
# 2. Posiblemente funcion en src/utils/validators.py

# Paso 3: Modificar con Claude Code general
> Agrega validacion de email en el schema UserCreate de 
  src/schemas/user.py usando un Pydantic validator. 
  Tambien agrega una funcion validate_email_format en 
  src/utils/validators.py que el schema pueda reutilizar.

# Claude Code modifica con comprension completa del contexto.
# Resultado: cambio que se integra correctamente con las 4
# capas de validacion existentes.

La diferencia: con Explore primero, descubriste las 4 capas de validación. Sin Explore, habrias modificado 1 capa y dejado las otras 3 inconsistentes.

Read-Only Como Feature: Casos de Uso

Caso 1: Investigar codebase de producción

# Escenario: tu equipo tiene un bug en produccion.
# No es tu servicio. Necesitas entender como funciona 
# rapidamente para diagnosticar.

> Usa Explore para investigar el servicio de notificaciones. 
  Necesito entender: como se envian emails, que pasa si el 
  servicio de email falla, y donde se loggea el resultado.

# Con Explore: investigacion completa sin riesgo.
# Sin Explore: la ansiedad de "y si modifico algo en produccion"
# te haria ir mas lento y ser mas conservador en tu investigacion.

Caso 2: Evaluacion tecnica de proyecto

# Escenario: tu empresa esta evaluando adquirir otro 
# producto y necesitas evaluar la calidad del codigo.

> Usa Explore para hacer una evaluacion de calidad de este codebase:
  1. Que patterns se usan y son consistentes?
  2. Hay tests? Que cobertura aproximada?
  3. Donde esta el tech debt mas critico?
  4. Que dependencias externas tiene y son actuales?

# Explore investiga sin tocar nada.
# Produces un reporte tecnico basado en hechos del codigo.

Caso 3: Code review profundo

# Escenario: un PR toca un modulo que no conoces bien.
# Necesitas entender el contexto antes de hacer review.

> Usa Explore para explicarme el modulo de inventory. 
  Un PR esta cambiando StockService.reserve_stock() y necesito 
  entender: que hace esa funcion, que la llama, y que pasa 
  si falla la reserva.

# Explore te da el contexto completo.
# Tu code review es informado, no superficial.

Caso 4: Onboarding de emergencia

# Escenario: 3am, alerta de PagerDuty, el servicio de 
# otro equipo esta fallando. Nadie del equipo responsable 
# esta disponible.

> Usa Explore para darme un overview rapido del servicio de checkout:
  - Donde esta el entry point principal?
  - Que dependencias externas tiene?
  - Donde se loggean errores?
  - Que circuit breakers o retry logic tiene?

# En 5 minutos tienes suficiente contexto para diagnosticar.
# Con Explore: rapido y seguro.
# Sin Explore: 30 minutos leyendo archivos al azar mientras 
# el servicio esta caido.

Comparacion: Explore vs Claude Code General

Cuando usar Explore? Cuando tu objetivo es entender, investigar, analizar, diagnosticar, evaluar.

Cuando usar Claude Code general? Cuando tu objetivo es escribir, modificar, refactorizar, crear, ejecutar.

Trade-off: Explore no puede hacer cambios. Si descubres algo que quieres corregir mientras investigas, necesitas cambiar a Claude Code general. El beneficio compensa: tu investigacion es mas profunda porque no se interrumpe con modificaciones.

Conexión con Proyecto

En el Proyecto del Módulo (capsula 05) vas a usar Explore exclusivamente para investigar un codebase. Todo lo que aprendiste en esta capsula es la base:

• Usaras la invocacion directa para tus primeras preguntas de exploracion
• Usaras prompts contextualizados para profundizar en areas especificas
• Usaras exploracion iterativa para conectar hallazgos entre modulos
• La garantia de read-only te dara confianza para investigar agresivamente

Todo lo que aprendes hoy se aplica directamente en la capsula 05.

Troubleshooting

Problema 1: Explore no encuentra archivos relevantes

Causa: Tu prompt es demasiado generico o el proyecto tiene una estructura no convencional.

Solución:

# En lugar de:
> Usa Explore para entender este proyecto.

# Se especifico:
> Usa Explore para encontrar el entry point de esta aplicacion. 
  Busca archivos como main.py, app.py, __main__.py, o cualquier 
  archivo que inicie la aplicacion.

Problema 2: Explore responde de forma superficial

Causa: Tu pregunta no tiene suficiente direccion.

Solución:

# En lugar de:
> Usa Explore para ver el modulo de usuarios.

# Pide profundidad especifica:
> Usa Explore para analizar el modulo de usuarios en detalle:
  1. Que funciones tiene y que hace cada una?
  2. Que dependencias externas usa?
  3. Como se conecta con otros modulos del proyecto?
  4. Que validaciones hace?

Problema 3: La respuesta mezcla varios temas sin profundidad

Causa: Pediste demasiadas cosas en un solo prompt.

Solución:

# En lugar de:
> Usa Explore para explicarme todo sobre autenticacion, 
  pagos, notificaciones, y reportes.

# Una pregunta a la vez:
> Usa Explore para explicarme como funciona la autenticacion.
# [Espera la respuesta]
> Ahora usa Explore para explicarme el modulo de pagos.

Problema 4: Explore dice que no puede encontrar algo que sabes que existe

Causa: El nombre del archivo o función no coincide con tu descripción.

Solución:

# Si sabes el nombre exacto:
> Usa Explore para leer el archivo src/utils/helpers.py y 
  explicarme que hace cada funcion.

# Si no sabes el nombre:
> Usa Explore para buscar funciones que manejen rate limiting 
  en este proyecto. Puede estar en utils, middleware, decoradores, 
  o cualquier otro lugar.

Problema 5: Claude Code no invoca Explore y responde directamente

Causa: Tu prompt no fue suficientemente claro sobre usar Explore.

Solución:

# Se explicito:
> Usa el Explore subagent (modo read-only) para investigar 
  como este proyecto maneja el caching.

# O inicia con el keyword:
> Explore: como maneja este proyecto el caching?

Ejercicios

Ejercicio 1: Primera invocacion de Explore (Fácil)

Clona un proyecto Python que no conozcas (sugerido: httpx, typer, o rich). Usa Explore para obtener un overview de la estructura del proyecto. Tu respuesta debe incluir: carpetas principales, que hace cada una, y el patron de arquitectura general.

# Clonar el proyecto
git clone --depth 1 https://github.com/encode/httpx /tmp/httpx-ejercicio
cd /tmp/httpx-ejercicio

# Iniciar Claude Code
claude

# Invocar Explore
> Usa Explore para darme un overview de la estructura de este proyecto: 
  carpetas principales, que contiene cada una, y que patron de 
  arquitectura sigue.

httpx/              -> Codigo principal del HTTP client
+-- _api.py         -> Funciones de conveniencia (get, post, etc.)
+-- _client.py      -> Client y AsyncClient (clases principales)
+-- _models.py      -> Request, Response, URL, Headers
+-- _transports/    -> Capa de transporte (conexion real)
tests/              -> Tests con pytest
docs/               -> Documentacion con MkDocs

Patron: Layered architecture (API -> Client -> Transport -> Network)

Ejercicio 2: Investigar un flujo específico (Fácil)

Usando el mismo proyecto, pide a Explore que trace un flujo específico: que pasa cuando un usuario hace una request HTTP GET. Documenta los pasos que Explore identifica.

> Usa Explore para trazar paso a paso que sucede cuando un usuario 
  ejecuta httpx.get("https://example.com"). Desde la funcion 
  httpx.get() hasta que recibe la respuesta.

1. httpx.get() en _api.py -> crea Client temporal -> client.get(url)
2. Client.get() en _client.py -> self.request("GET", url)
3. Client.request() -> construye Request -> aplica middleware -> self._send()
4. Client._send() -> transport.handle_request(request)
5. Transport -> httpcore -> socket -> envio real
6. Response vuelve: httpcore -> Transport -> Client -> usuario

Ejercicio 3: Busqueda semantica (Medio)

Pide a Explore que encuentre donde el proyecto maneja errores de red. La instruccion clave: NO busques la palabra "error" — busca donde se detectan y manejan problemas de conectividad.

> Usa Explore para encontrar donde este proyecto detecta y maneja 
  problemas de conectividad de red. No busques la palabra "error" — 
  encuentra los mecanismos reales: excepciones, retry logic, timeouts, 
  y cualquier otro mecanismo de manejo de problemas de red.

Manejo de problemas de red:

1. Excepciones: _exceptions.py define ConnectError, TimeoutException, 
   ReadTimeout, WriteTimeout, PoolTimeout
2. Mapping: _transports/default.py tiene map_httpcore_exceptions() 
   que convierte excepciones httpcore a excepciones httpx
3. Timeouts: _config.py define Timeout class con connect, read, 
   write, pool timeouts configurables
4. Retries: Client tiene max_redirects pero no retry automatico
   (los usuarios deben implementar retry manualmente)

Ejercicio 4: Explore iterativo (Medio)

Haz 3 preguntas en secuencia a Explore, donde cada pregunta profundiza sobre la respuesta anterior. Empieza con un overview general, luego profundiza en un módulo, luego profundiza en una función especifica de ese módulo.

# Pregunta 1: Overview
> Usa Explore para darme un overview de los modulos principales 
  de este proyecto y su responsabilidad.

# [Explore responde con lista de modulos]

# Pregunta 2: Profundizar en _client.py
> Usa Explore para analizar _client.py en detalle: que clases tiene, 
  cuales son los metodos principales, y como se conecta con otros modulos.

# [Explore responde con detalles de _client.py]

# Pregunta 3: Profundizar en Client.request()
> Usa Explore para desglosar la funcion Client.request() linea por linea: 
  que hace cada paso, que validaciones aplica, y que otros metodos llama.

Client.request() en _client.py:

1. Construye Request object con URL, method, headers, content
2. Aplica auth (si se configuro auth en el Client)
3. Prepara cookies del CookieJar
4. Llama self._send_with_response()
   a. Maneja redirects (si follow_redirects=True)
   b. Para cada redirect, verifica max_redirects
   c. Construye nuevo Request para la URL de redirect
5. Lee response stream si es necesario
6. Retorna Response object

Llama a: _build_request(), _send(), _send_handling_redirects()
Usa: _merge_url(), _merge_headers(), _merge_cookies()

Ejercicio 5: Comparar Explore vs grep (Difícil)

Elige una pregunta de investigacion. Primero intentala con grep (busqueda de texto). Luego intentala con Explore (busqueda semantica). Documenta la diferencia en resultados, tiempo, y completitud.

grep -rn "redirect" httpx/ --include="*.py"
# Resultado: ~40 lineas que contienen "redirect"
# Muchas son comentarios, strings, o nombres de variables
# Necesitas leer cada una para determinar cual es relevante
# Tiempo: ~5-10 minutos para filtrar y entender

> Usa Explore para explicarme como este proyecto maneja 
  HTTP redirects: donde se detectan, como se siguen, 
  que limites hay, y que pasa si se exceden.

Manejo de redirects en httpx:

1. Deteccion: Client._send_handling_redirects() en _client.py
   - Verifica status codes 301, 302, 303, 307, 308
   - Lee header "Location" para la URL de destino

2. Seguimiento: 
   - Si follow_redirects=True (default: False), sigue automaticamente
   - Construye nuevo Request con la URL de redirect
   - Para 303: cambia method a GET
   - Para 307/308: mantiene method original

3. Limites:
   - max_redirects=20 (default en Client)
   - Si se excede: lanza TooManyRedirects exception

4. Configuracion:
   - follow_redirects parametro en Client() y en request()
   - max_redirects parametro en Client()

Resumen

En esta capsula aprendiste:

• Que es Explore: Un subagent de Claude Code que opera en modo read-only, disenado para investigacion de codebases
• Como invocarlo: 3 metodos — invocacion directa, prompts contextualizados, exploracion iterativa
• Read-only es una feature: Te da confianza total para investigar sin riesgo de modificaciones accidentales
• Que puede y no puede hacer: Lee, busca, analiza, responde — pero no escribe, ejecuta, ni modifica
• Explore vs Claude Code general: Explore para investigar (entender), Claude Code general para implementar (modificar)
• El workflow optimo: Explore primero (investigar), planificar (tu cerebro), Claude Code general después (implementar)
• Preguntas especificas producen mejores resultados: "Como maneja autenticación?" > "Mira este codebase"

Proxima capsula: Busqueda Semantica vs Grep — Encontrar por Significado — la diferencia entre buscar texto y buscar significado, y por que cambia tu productividad de investigacion.

Recursos Adicionales

1. Claude Code Documentation — Subagents — Documentación oficial sobre subagents y Explore.
2. Agentic Patterns — Anthropic Research — Patrones de agentes autonomos para investigacion de código.
3. Read-Only Agents for Code Analysis — Research sobre agentes de solo lectura y su ventaja en seguridad.
4. The Art of Code Reading — Diomidis Spinellis — Tecnicas clasicas de lectura de código, complementarias al approach con AI.
5. Understanding Software — Max Kanat-Alexander — Framework para entender software complejo.
6. httpx Documentation — Documentación del proyecto usado en las demos de esta capsula.

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