Módulo 1: Onboarding con AI — 5-10x Más Rápido

Módulo 1: Onboarding con AI — 5-10x Mas Rápido

Descripción de la capsula

Vas a aprender la habilidad mas fundamental para trabajar con código existente: entender rápidamente un codebase que no escribiste. Sin esta habilidad, todo lo que viene después en esta guia — refactoring, migracion, modernizacion — es imposible o peligroso. Modificar código sin entenderlo es la fuente número uno de bugs en equipos de desarrollo, y la principal razon por la que los developers nuevos tardan semanas en ser productivos.

El problema es economico y práctico. Un developer senior tarda 2-4 semanas en entender un codebase mediano. Multiplica eso por cada nuevo integrante del equipo, cada cambio de proyecto, cada contribucion a open source. Con Claude Code y un método sistematico, ese tiempo se reduce a horas — no porque omitas pasos, sino porque la AI lee y procesa código orders of magnitude mas rápido que un humano. Donde tu lees un archivo a la vez, Claude Code lee directorios enteros. Donde tu haces grep y pierdes contexto, Claude Code traza flujos de datos a traves de decenas de archivos en segundos.

Este módulo te da el método y las herramientas para que el onboarding a cualquier codebase deje de ser un cuello de botella en tu carrera. Las 5 preguntas iniciales, el orden de exploracion, y las tecnicas de documentación que aprenderas aquí se aplican a cualquier proyecto — desde un microservicio de 5K lineas hasta un monorepo de 500K.

Contexto del Módulo

Donde estamos?

Esta es la Guia #8 del Claude Code Agentic Development Path — "Refactoring & Legacy Code with Claude Code." Es la segunda guia del bloque "Calidad y Mantenimiento" dentro del nivel Profesional del path.

Prerequisites completados:

Guia	Lo que construiste
#1 — How Coding Agents Work	Base conceptual: como piensan, planifican y ejecutan los agentes
#2 — Claude Code Foundations	Habilidad practica: dominio de Claude Code como herramienta diaria
#3 — Prompt Engineering with Claude Code	Comunicación profesional: prompts que producen resultados predecibles
#4 — AI Coding Tools Landscape	Perspectiva estrategica: evaluacion del ecosistema, toolkit justificado
#5 — Claude Code & MCP	Integraciones custom con Model Context Protocol
#6 — Debugging & Code Review	Debugging profesional y code review con agentes
#7 — Testing with Claude Code	Estrategia de testing, TDD, tests como red de seguridad

Hasta ahora has trabajado principalmente con código nuevo: creaste proyectos desde cero, aplicaste TDD, generaste código fresco. Pero la realidad profesional es diferente: el 80% del tiempo de un developer se gasta en código que ya existe — entendiendolo, manteniendolo, y mejorandolo. Este módulo marca esa transicion.

Hacia donde vamos?

La guia tiene 3 phases progresivas y 8 modulos. Cada phase construye sobre la anterior:

Phase 1: Entender Codebases (Modulos 1-3)
+-- Modulo 1: Onboarding con AI — 5-10x Mas Rapido       <-- ESTAS AQUI
+-- Modulo 2: Agentic Research con Explore Subagent
+-- 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

Phase 1 completa es sobre entender codebases — no sobre modificarlos. Los primeros 3 modulos invierten todo el esfuerzo en comprension porque es el principio fundamental de esta guia: entender antes de modificar. Cada minuto invertido en comprension ahorra horas de debugging.

La progresion dentro de Phase 1:

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

Cada módulo anade una capa de profundidad. En el Módulo 1 aprendes a explorar. En el Módulo 2 usas una herramienta disenada especificamente para exploracion. En el Módulo 3 generas representaciones visuales y textuales de la arquitectura.

Por que este módulo importa?

El problema que resuelve

Piensa en la ultima vez que te uniste a un proyecto existente. Que hiciste?

Dia 1:  Abres el repo. Ves 200 archivos. No sabes por donde empezar.
Dia 2:  Lees el README (si existe). Intentas correr el proyecto.
Dia 3:  Empiezas a explorar archivos al azar. Abres main.py, ves imports.
Dia 5:  Empiezas a entender vagamente la estructura.
Dia 10: Ya puedes hacer cambios pequenos con miedo.
Dia 15: Entiendes el data flow principal.
Dia 20: Te sientes "productivo" — pero aun hay modulos que no tocas.

Ese timeline es optimista. Para codebases grandes o legacy, duplica los numeros. Y multiplica por cada persona nueva que se une al equipo.

Ahora imagina esto:

Hora 0:  Abres el repo con Claude Code.
Hora 1:  Tienes un mapa completo de la estructura y entry points.
Hora 2:  Entiendes el data flow principal y los patterns usados.
Hora 3:  Has identificado tech debt y areas de riesgo.
Hora 4:  Produces un onboarding doc que otro developer puede usar.
Hora 5:  Haces un cambio pequeno para validar tu comprension.

Esa es la diferencia entre onboarding manual y onboarding con AI: 5-10x mas rápido, no porque omitas pasos, sino porque Claude Code lee y procesa código orders of magnitude mas rápido que un humano.

La inversion de perspectiva

La mayoria de developers usa Claude Code así:

"Generame un endpoint de autenticacion"
"Escribe tests para esta funcion"
"Crea un modelo de datos para usuarios"

Todo es output: generar, escribir, crear. Pero Claude Code es igualmente poderoso — quizas mas — como herramienta de input:

"Explicame la estructura de este proyecto"
"Que hace esta funcion y por que esta implementada asi?"
"Cual es el data flow desde que llega un request hasta la respuesta?"
"Donde esta el tech debt mas critico en este codebase?"

Vas a aprender a usar Claude Code como reader, no solo como writer. Y eso cambia fundamentalmente como trabajas con codebases existentes.

Los datos son claros

La estadistica respalda esta inversion:

80% del tiempo de un developer se gasta en leer y entender código, no en escribirlo
2-4 semanas es el promedio de onboarding a un codebase mediano para un developer senior
$15K-$30K en productividad perdida por cada developer que hace onboarding manual
5-10x es la aceleracion medida cuando se aplica un método sistematico con AI

No son numeros teoricos — son el resultado de medir onboardings reales en equipos de desarrollo de diferentes tamanos.

El Contexto de la Industria

Por que ahora?

El onboarding siempre fue un problema. Pero hasta hace poco, no habia alternativa: leias código, preguntabas a companeros, y eventualmente construias un mental model. Eso cambio:

2022: GitHub Copilot sale de beta -> developers experimentan con AI para escribir codigo
2023: ChatGPT/Claude generan codigo complejo -> adopcion masiva en empresas
2024: AI genera 30%+ del codigo nuevo en equipos que usan herramientas
2025: Claude Code lanza context windows de 200K -> analisis de codebases completos posible
2026: Claude Code con Opus alcanza 1M tokens -> onboarding de codebases medianos en una sesion

La capacidad de AI para leer código evoluciono tan rápido como la capacidad de escribirlo. Pero la mayoria de developers no se dio cuenta porque estaban enfocados en el writing side.

El skill gap emergente

Hay dos tipos de developers en 2026:

Tipo A	Tipo B
Usa AI solo para generar código	Usa AI para leer Y generar código
Onboarding: 2-4 semanas	Onboarding: 2-4 horas
Depende de mentores para entender codebases	Autonomo con Claude Code
Productividad empieza en semana 4	Productividad empieza en dia 1
Comprension individual (no documenta)	Comprension compartida (genera docs)

El Tipo B no es "mejor developer." Es un developer con el mismo talento que usa una herramienta mas efectivamente. Este módulo te mueve de Tipo A a Tipo B.

Casos de uso reales

Estos son escenarios donde el onboarding con AI tiene impacto inmediato:

Consultoria y freelancing. Entras a un proyecto nuevo cada 1-3 meses. Tu velocidad de onboarding es directamente proporcional a tu ingreso. Un consultor que entiende el codebase en 2 horas vs 2 semanas puede cobrar por valor entregado, no por tiempo sentado.
Open source contributions. Quieres contribuir a un proyecto pero la barrera de entrada es entender el codebase. Con Claude Code, puedes entender un proyecto como httpx o FastAPI en una hora y hacer tu primer PR informado.
Rotacion de equipos. En empresas grandes, los developers rotan entre equipos cada 6-12 meses. Sin método, cada rotacion es un reset. Con método, cada rotacion es un proceso predecible de unas horas.
Due diligence tecnica. Necesitas evaluar el estado técnico de un codebase (adquisicion, contratacion de equipo, decisión de refactor vs rewrite). Con Claude Code, puedes tener un assessment en horas.
Incident response. Un servicio falla a las 3am. No es tu servicio. Necesitas entender el codebase lo suficiente para diagnosticar y mitigar. Con Claude Code, puedes hacer onboarding de emergencia en minutos.

Autodiagnostico: Donde Estas Hoy?

Antes de avanzar, hazte estas preguntas honestamente. No hay respuestas correctas — el objetivo es saber tu punto de partida.

Test rápido de 5 preguntas

1. Cuando te asignan un codebase nuevo, que haces primero?

(a) Abro archivos al azar y empiezo a leer
(b) Leo el README y la documentación
(c) Tengo un método sistematico (preguntas en orden)
(d) Le pido a un companero que me explique

2. Cuanto tardaste la ultima vez en entender un proyecto nuevo?

(a) Dias
(b) 1-2 semanas
(c) 3-4 semanas
(d) Nunca senti que lo entendi completamente

3. Usas Claude Code para entender código existente?

(a) No, solo para generar código nuevo
(b) A veces, para preguntas puntuales
(c) Si, regularmente para explorar codebases
(d) No uso Claude Code

4. Cuando terminas de explorar un codebase, que produces?

(a) Nada — la comprension esta en mi cabeza
(b) Algunas notas personales
(c) Un documento que otro developer podria usar
(d) No habia pensado en producir algo

5. Puedes explicar el data flow de tu proyecto actual sin mirar código?

(a) Mas o menos — los flujos principales si
(b) Si, con detalle
(c) No estoy seguro de algunos flujos
(d) No, tendria que revisarlo

Interpretacion

Mayoria de (a) o (d): Estas empezando. Este módulo te dara un método completo que no tenias.
Mayoria de (b): Tienes intuicion pero no estructura. El framework de 5 preguntas le dara forma.
Mayoria de (c): Ya tienes una base solida. Este módulo la formalizara y acelerara con Claude Code.

No importa donde estes — lo que importa es que al terminar este módulo tendras un método concreto y probado.

El denominador comun

Independientemente de tus respuestas, hay algo que aplica a todos: nadie te enseno un método sistematico para explorar codebases. Lo aprendiste por prueba y error, copiaste lo que viste hacer a otros, o simplemente te lanzaste al código y esperaste lo mejor.

Este módulo te da lo que la universidad, los bootcamps, y la mayoria de los tutoriales omiten: un framework estructurado para entender código ajeno. No es intuitivo — es metodico. No depende de tu experiencia — funciona para juniors y seniors. Y con Claude Code, es dramaticamente mas rápido que hacerlo manualmente.

Vocabulario Clave

Antes de avanzar, estos son los terminos que usaras a lo largo de todo el módulo:

Termino	Definición
Onboarding	El proceso de familiarizarte con un codebase nuevo — entender su estructura, patterns, data flow, y convenciones
Mental model	Tu representacion interna de como funciona un sistema — que componentes tiene, como interactuan, donde estan los limites
Entry point	El archivo o función donde comienza la ejecución del programa (main.py, app.py, index.js) o donde entran los requests
Data flow	Como los datos viajan a traves del sistema — desde input hasta output, pasando por transformaciones
Tech debt	Atajos o decisiones tecnicas que aceleran el desarrollo hoy pero crean problemas manana
Codebase exploration	El proceso de navegar y entender un repositorio de código de forma sistematica
Architecture patterns	Estructuras recurrentes de organización de código: MVC, service layer, repository pattern, etc.
Onboarding doc	Documento que resume la comprension de un codebase para que otros puedan entenderlo mas rápido
Knowledge tribal	Conocimiento sobre el codebase que solo existe en la cabeza de personas, no en documentación

No necesitas memorizar todo ahora. Los iras internalizando a medida que los uses en las capsulas practicas.

Objetivo Profesional

Al final de este módulo podras:

Aplicar un método sistematico de onboarding usando las 5 preguntas iniciales: estructura, entry points, data flow, patterns, tech debt — en ese orden, del big picture a los detalles.
Explorar un codebase desconocido con Claude Code preguntando en la secuencia correcta: estructura de directorios primero, entry points después, flujo de datos, patterns, y finalmente tech debt.
Crear un mental model del codebase que incluya layers, modulos principales, dependencias clave, y el flujo de datos — todo en menos de una hora para un codebase mediano.
Documentar hallazgos produciendo un "onboarding doc" que incluya structure overview, key patterns, gotchas, y entry points — un artefacto tangible que otro developer podria leer.
Validar tu comprension haciendo un cambio pequeno (fix a typo, agregar un test, documentar una función) y verificando que tu mental model es correcto.
Medir la diferencia comparando cuanto tardaste con Claude Code vs cuanto habrias tardado manualmente, con metricas concretas.

El cambio de perspectiva

Entras a este módulo sabiendo usar Claude Code para generar código nuevo. Sales sabiendo que Claude Code es igual de poderoso — quizas mas — para leer y analizar código existente. Esta inversion de perspectiva es el insight central: Claude Code no es solo un writer, es un reader excepcional.

Por que esto importa en tu carrera

Entender código existente no es un skill "de junior." Es el skill que mas tiempo consume a developers de cualquier nivel:

Junior: Se une a un equipo, necesita entender el codebase para ser productivo
Mid-level: Cambia de proyecto cada 6-12 meses, necesita onboarding rápido
Senior: Revisa PRs de otros, necesita entender el contexto rápidamente
Tech Lead: Evalua la arquitectura de proyectos que no escribio
Consultant: Entra a proyectos desconocidos constantemente, cobra por velocidad

En todos los casos, la velocidad de onboarding determina la velocidad de todo lo demas. Si puedes entender un codebase en horas en lugar de semanas, eres 5-10x mas efectivo desde el dia uno.

Progresion del Módulo

Mapa del Módulo

Capsula	Tema	Que aprenderas
02	El Costo del Onboarding Manual	Por que el onboarding toma 2-4 semanas, cuanto cuesta en productividad, y como AI transforma la ecuacion. Primera demo con Claude Code
03	Exploracion Sistematica con Claude Code	Las 5 preguntas iniciales, por que el orden importa, prompts practicos para cada pregunta. Framework de exploracion completo
04	Crear el Mental Model	Como construir tu mental model: layers, modulos, dependencias, data flow. Tecnicas para visualizar y validar comprension
05	Documentar Hallazgos — El Onboarding Doc	Producir un artefacto tangible: structure overview, patterns, gotchas, entry points. Documentación que otros pueden usar
06	Proyecto: Onboarding a Codebase Open-Source	Mini-proyecto integrador: explorar un proyecto real, documentar, hacer un cambio pequeno, medir la diferencia

Flujo de aprendizaje

Capsula 02: El Problema          Capsula 03: El Metodo
(por que es lento)           ->  (5 preguntas, orden, prompts)
        |                                 |
        v                                 v
Capsula 04: El Mental Model      Capsula 05: El Documento
(layers, dependencias, flow) ->  (onboarding doc tangible)
        |                                 |
        +----------------+---------------+
                         v
                 Capsula 06: El Proyecto
           (todo junto en un codebase real)

Cada capsula construye sobre la anterior. Las capsulas 02-03 establecen el "por que" y el "como." Las capsulas 04-05 producen outputs concretos. La capsula 06 integra todo en practica real.

La narrativa del módulo

Primero entenderas el problema con numeros reales — cuanto cuesta el onboarding manual y por que es tan lento (capsula 02). Después aprenderas el método sistematico: las 5 preguntas que debes hacer y en que orden (capsula 03). Con ese método, construiras un mental model del codebase — no solo "lo entiendes," sino que tienes una representacion clara en tu cabeza (capsula 04). Luego convertiras ese mental model en un documento tangible que otros pueden usar (capsula 05). Finalmente, integras todo en un proyecto real con un codebase open-source (capsula 06).

La progresion es intencional: no puedes documentar si no entiendes, no puedes entender sin método, y no puedes apreciar el método sin conocer el costo de no tenerlo.

Conexión con Proyecto

Mini-proyecto del módulo: Onboarding a codebase open-source

En la capsula 06 vas a tomar un proyecto open-source real (sugerido: un proyecto Python mediano como httpx, typer, FastAPI, o similar), explorarlo con Claude Code usando el método sistematico, documentar tu comprension, y hacer un cambio pequeno (fix a typo, agregar un test, documentar una función).

El foco no es el cambio — es la velocidad y profundidad del onboarding.

Lo que entregaras:

✅ Onboarding doc completo del codebase elegido
✅ Mental model documentado (structure, patterns, data flow)
✅ Un cambio pequeno que demuestre comprension
✅ Medicion: tiempo real vs estimado manual

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

El Módulo 8 es una Migracion Completa de Proyecto Legacy. El onboarding que aprendes aquí es el primer paso obligatorio de esa migracion. No puedes migrar lo que no entiendes. El pattern de toda la guia queda establecido en este módulo: entender primero, modificar después.

Modulo 1: Onboarding -> entender el codebase              -+
Modulo 2: Explore -> investigar en profundidad              |
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                -+

Limites: Que NO Se Hara

Para mantener el foco y evitar scope creep, este módulo tiene limites claros:

❌ No vas a modificar código significativamente. El cambio de la capsula 06 es deliberadamente pequeno. Modificar código viene en los modulos 4-7.
❌ No vas a usar el Explore subagent. Eso es el Módulo 2. Aquí usas Claude Code directamente.
❌ No vas a generar dependency maps ni diagramas de arquitectura formales. Eso es el Módulo 3. Aquí construyes un mental model mas informal.
❌ No vas a trabajar con codebases extremadamente grandes (100K+ lineas). Context management viene en el Módulo 6. Aquí trabajas con codebases medianos (5K-30K lineas).
❌ No vas a cubrir refactoring de UI o frontend. El scope de la guia es backend/Python.
❌ No vas a configurar CI/CD ni pipelines. Eso esta cubierto en la Guia #10 del path.

Lo que si cubrimos a profundidad:

✅ Método sistematico de exploracion con las 5 preguntas
✅ Claude Code como herramienta de lectura y análisis
✅ Documentación como output del onboarding
✅ Validación de comprension con cambios pequenos
✅ Medicion del impacto (tiempo AI vs manual)

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 listar las 5 preguntas iniciales en orden	Sin mirar notas, recitas: estructura, entry points, data flow, patterns, tech debt
Puedes explorar un codebase desconocido en < 1 hora	Timer desde cero hasta mental model documentado en codebase mediano
Produces un onboarding doc con las secciones correctas	Documento incluye: overview, structure, entry points, patterns, data flow, gotchas
Haces un cambio pequeno informado por tu comprension	El cambio demuestra que entiendes donde y por que modificar
Puedes articular la diferencia AI vs manual	Tienes un número concreto: "Me tomo X minutos con Claude Code; habria tardado Y horas manualmente"

Criterios de excelencia (opcionales):

✅ Tu onboarding doc es suficientemente bueno para que otro developer lo lea y entienda el codebase
✅ Identificaste al menos un gotcha o quirk del codebase que no es obvio en la documentación oficial
✅ Tu cambio pequeno incluye un test o mejora de documentación, no solo un typo fix

Como se ve el exito en la practica

Antes de este módulo:

Nuevo codebase -> Abrir archivos al azar -> Leer README
-> Intentar correr -> Confundirte -> 2-4 semanas

Después de este módulo:

Nuevo codebase -> Claude Code: estructura? -> Entry points?
-> Data flow? -> Patterns? -> Tech debt?
-> Mental model en 1-2 horas -> Onboarding doc -> Validar con cambio

La diferencia no es solo velocidad — es profundidad. Con el método sistematico, no te pierdes cosas que la exploracion random omite. Y con el onboarding doc, tu comprension beneficia a todo el equipo.

La pregunta de validación final:

Si alguien te da un codebase de 10K lineas que nunca has visto y te dice "tienes una hora para entenderlo y explicarmelo," puedes hacerlo con confianza?

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

Como medir tu progreso

Lleva un registro durante tus primeras 3 exploraciones de codebases después de completar el módulo. Para cada una, registra:

Metrica	Que medir
Tiempo total de las 5 preguntas	Desde la primera pregunta hasta tener un mental model básico
Calidad del onboarding doc	Pidele a un companero que lo lea — entiende el proyecto?
Validación del cambio	Tu cambio pequeno funciono a la primera? (Si = buen mental model)
Comparacion con manual	Cuanto habrias tardado sin Claude Code? Estima honestamente

Después de 3 exploraciones, veras tu patron personal: donde eres mas rápido, que tipo de preguntas te dan mejor información, y donde necesitas profundizar. Esa calibracion es el verdadero output de este módulo.

Prerequisites del Módulo

Conocimiento requerido:

✅ Claude Code básico (guias #1-6 del path): saber invocar Claude Code, hacer prompts, trabajar en terminal
✅ Testing con Claude Code (guia #7): entender que son los tests y como correrlos (los usaras para validar)
✅ Python intermedio: leer código Python sin dificultad (no necesitas ser experto, pero si fluido)
✅ Git básico: clonar repos, ver historial, crear branches

No necesitas:

❌ Experiencia con el codebase que vas a explorar — el punto es que sea desconocido
❌ Conocimiento de todos los frameworks — se explican en contexto
❌ Experiencia previa con refactoring — eso viene después
❌ Un proyecto propio — usaras proyectos open-source

Setup técnico:

Herramienta	Para que
Claude Code instalado y configurado	Exploracion y análisis de código
Terminal con acceso a Git	Clonar repos, ver historial
Editor de texto	Crear documentación (onboarding doc)
Conexión a internet	Clonar proyectos open-source

Verificacion rapida de setup

# Verifica Python
python --version
# Esperado: Python 3.10+

# Verifica Claude Code
claude --version
# Esperado: version instalada

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

# Verifica que puedes clonar
git clone --depth 1 https://github.com/encode/httpx /tmp/httpx-test
# Esperado: clona sin errores

Si algo no funciona, revisa las Guias 1-4 antes de continuar. Este módulo asume que tu entorno esta listo.

El Principio Central

Entender antes de modificar

Este principio debe quedar grabado desde la primera capsula. No es una sugerencia — es un imperativo profesional:

Cada minuto invertido en comprension ahorra horas de debugging.

El error mas caro en desarrollo de software no es un bug de syntax o un test que falla. Es modificar código que no entiendes. Produces un fix que parece funcionar, pero rompe algo tres niveles mas abajo que no sabias que existia. Pasas horas debuggeando un problema que creaste tu mismo porque no entendias el sistema.

Con Claude Code, la comprension ya no es un cuello de botella. Puedes preguntar "como fluyen los datos desde el endpoint /users hasta la base de datos?" y obtener una respuesta que mapea todo el flujo en segundos. Puedes preguntar "que patterns se usan en este codebase?" y obtener un análisis que te habria tomado dias descubrir manualmente.

Claude Code es un reader excepcional

La mayoria de developers solo usan Claude Code para escribir código. Ese es un uso legitimo, pero incompleto. Claude Code es igual de poderoso — quizas mas — para leer código:

Claude Code como Writer	Claude Code como Reader
Genera código nuevo	Analiza código existente
Crea funciones y clases	Explica funciones y clases
Escribe tests	Identifica que tests faltan
Produce documentación	Descubre patrones no documentados

Este módulo te ensena a usar Claude Code en su rol de reader. Cuando domines ambos roles — writer y reader — tendras una herramienta que cubre el ciclo completo del desarrollo de software.

El método importa mas que la herramienta

Las 5 preguntas iniciales que aprenderas funcionan con o sin AI. Son un framework de onboarding que cualquier developer deberia seguir. Pero con AI, van 5-10x mas rápido. El método es portable: si manana usas otra herramienta, las preguntas siguen siendo las mismas. Lo que cambia es la velocidad de obtener respuestas.

Lo Que Viene Después de Este Módulo

Módulo 2: Agentic Research con Explore Subagent

La transicion directa: "Ya sabes como explorar un codebase con Claude Code directamente. Ahora aprende la herramienta disenada especificamente para investigacion: el Explore subagent."

El Explore subagent tiene caracteristicas que lo hacen ideal para exploracion:

Read-only: No puede modificar nada. Puedes investigar sin miedo a romper algo.
Busqueda semantica: Encuentra código por significado, no solo por texto. "Donde se maneja autenticación?" sin saber el nombre de la función.
Optimizado para investigacion: Esta disenado para buscar, leer, y responder preguntas sobre código.

El método que aprendes en el Módulo 1 se potencia con la herramienta del Módulo 2. Primero el framework mental, luego la herramienta especializada.

Módulo 3: Entender Arquitectura Existente

Después del Explore subagent, el siguiente paso es profundizar la comprension hasta nivel arquitectural. El Módulo 3 te ensena a generar representaciones visuales y textuales de la arquitectura:

Dependency maps: Que módulo depende de que. Grafos de dependencias generados por Claude Code.
Flow analysis: Seguir un request desde el entry point hasta la respuesta, con todos los pasos intermedios.
Pattern identification: Reconocer MVC, repository pattern, service layer, y otros patterns comunes.
Anti-pattern detection: Identificar circular dependencies, god objects, y spaghetti code.

La progresion de Phase 1 completa:

Modulo 1: "Entiendo el codebase" (onboarding rapido)
    |
    v
Modulo 2: "Puedo investigar en profundidad" (explore subagent)
    |
    v
Modulo 3: "Puedo visualizar y explicar la arquitectura" (maps + diagrams)

Cada módulo te da un nivel mas profundo de comprension. Al terminar Phase 1, no solo entiendes un codebase — puedes crear un mapa completo que otros pueden usar.

Distribucion de Tiempo Estimada

Capsula	Tiempo estimado	Actividad principal
01 (esta)	10-15 min	Lectura: objetivos y contexto del módulo
02	15-20 min	Lectura + ejercicios: el costo del onboarding manual
03	20-25 min	Lectura + ejercicios: exploracion sistematica
04	15-20 min	Lectura + ejercicios: crear mental model
05	15-20 min	Lectura + ejercicios: documentar hallazgos
06	30-45 min	Proyecto: onboarding a codebase open-source
Total	~1.75-2.5 hrs

El módulo esta disenado para completarse en una sesión larga o dos sesiones cortas. Si necesitas dividirlo, el punto natural de pausa es después de la capsula 03 (las 5 preguntas iniciales).

Resumen

✅ Este módulo abre la guia porque entender código existente es la habilidad mas fundamental para refactoring
✅ El onboarding manual toma 2-4 semanas; con Claude Code y método sistematico, se reduce a horas
✅ Las 5 preguntas iniciales: estructura, entry points, data flow, patterns, tech debt — en ese orden
✅ Claude Code no es solo un writer — es un reader excepcional que analiza codebases completos
✅ El principio central: entender antes de modificar. Cada minuto de comprension ahorra horas de debugging
✅ El output no es "ahora lo entiendo" — es un onboarding doc tangible que otros pueden usar
✅ El proyecto del módulo: onboarding a codebase open-source con medicion de tiempo AI vs manual
✅ Este módulo establece el pattern de toda la guia: primero entender, después modificar

Recursos Adicionales

Working Effectively with Legacy Code — Michael Feathers — El libro de referencia sobre trabajar con código legacy. Establece el principio de tests antes de cambios.
Claude Code Documentation — Anthropic — Documentación oficial de Claude Code con features de análisis de código.
The Pragmatic Programmer — Hunt & Thomas — Capitulos sobre entender sistemas existentes y la importancia del conocimiento del dominio.
Refactoring — Martin Fowler — El catalogo de refactoring patterns. Contexto conceptual para lo que viene en modulos posteriores.
Software Design X-Rays — Adam Tornhill — Análisis de codebases usando datos de VCS. Complementa el análisis con AI.
Understanding Legacy Code — Nicolas Carlo — Blog con tecnicas practicas para entender y mejorar código legacy.
Awesome Onboarding — GitHub — Recursos sobre onboarding de developers a proyectos de software.

Siguiente capsula: El Costo del Onboarding Manual y Por Que AI lo Transforma — por que tardamos semanas en entender un codebase, cuanto cuesta en productividad, y como Claude Code cambia la ecuacion.

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

Siguiente →El Costo del Onboarding Manual y Por Que AI lo Transforma