Módulo 1: Solo 3% Confía — Por Qué y Qué Hacer

Módulo 1: Solo 3% Confía — Por Qué y Qué Hacer

Siguiente →

Módulo 1: Solo 3% Confía — Por Qué y Qué Hacer

Descripción de la cápsula

Si le preguntas a 100 developers si confían en el código que genera AI, solo 3 dirán que sí con seguridad. Eso no es opinión — es el resultado de encuestas recientes en la industria. Y el dato no significa que AI sea mala generando código. Significa que la mayoría de developers no tiene un proceso para evaluar cuándo confiar y cuándo no.

En este módulo vas a entender por qué esa desconfianza existe, por qué los dos extremos (aceptar todo sin revisar o rechazar AI por completo) son igualmente peligrosos, y cómo desarrollar lo que llamamos confianza calibrada: un punto medio profesional donde verificas lo que importa y confías en lo routine. Al final tendrás un framework básico que puedes usar mañana en tu trabajo.

Esta guía completa tiene 8 módulos en 3 phases. Este primer módulo establece la base de todo: sin entender el problema, las técnicas de los módulos 2-8 son una lista de cosas que hacer sin motivación ni contexto.

Contexto del Módulo

¿Dónde estamos?

Esta es la Guía #6 del Claude Code Agentic Development Path. Hasta ahora has aprendido a usar Claude Code en terminal (Guía 1), a escribir prompts efectivos (Guía 2), a entender workflows agénticos (Guía 3), a configurar CLAUDE.md y memoria (Guía 4), y a trabajar con MCP (Guía 5).

Todas esas guías te enseñaron a generar código con Claude Code. Esta guía te enseña a validar ese código. Es el skill que separa a un developer que usa AI de un developer que domina AI.

¿Hacia dónde vamos?

Este módulo es el primero de tres en la Phase 1: Entender el Problema:

Phase 1: Entender el Problema (Módulos 1-3)
├── Módulo 1: Solo 3% Confía ← ESTÁS AQUÍ
│   → Awareness del problema + framework básico
├── Módulo 2: Mental Models para AI Code
│   → Frameworks de pensamiento (Managing an Intern, Circuit Breaker, Trust Calibration)
└── Módulo 3: Detectar Hallucinations
    → El error más peligroso: código que se ve correcto pero no lo es

Phase 2: Code Review Profesional (Módulos 4-6)
├── Módulo 4: Code Review de Output AI
├── Módulo 5: Patrones de Error Comunes
└── Módulo 6: Debugging con Claude Code

Phase 3: Mastery (Módulos 7-8)
├── Módulo 7: Subagents, Regenerar vs Editar
└── Módulo 8: Proyecto Integrador (code review de codebase completo)

El arco de la guía es claro: empiezas entendiendo el problema (Phase 1), luego adquieres técnicas concretas (Phase 2), y finalmente demuestras mastery con un proyecto real (Phase 3).

¿Por qué este módulo importa?

El problema que resuelve

La mayoría de developers que usan AI coding tools está en una de estas situaciones:

Situación A: "Acepto todo"
- Claude Code genera código → lo acepto si funciona
- Resultado: bugs sutiles, security holes, lógica incorrecta
- No me doy cuenta hasta que algo explota en producción

Situación B: "Rechazo todo"
- Claude Code genera código → lo reescribo todo
- Resultado: pierdo productividad, no aprovecho la herramienta
- Podría estar haciendo trabajo de mayor valor

Situación C: "Depende del día"
- A veces reviso, a veces no → sin criterio claro
- Resultado: calidad inconsistente, no aprendo cuándo confiar
- Cada generación es una moneda al aire

Este módulo te lleva de A, B, o C a la Situación D: confianza calibrada. Verificas lo que importa con criterio, confías en lo routine, y tu proceso es consistente independientemente de la presión o el día.

Los datos son claros

La estadística no miente:

  • 76% de developers usa o planea usar AI tools (Stack Overflow, 2024)
  • Solo 3% confía altamente en el output sin revisión
  • 39% de aumento en "code churn" (código que se reescribe rápido) con AI tools
  • 56% de organizaciones reporta vulnerabilidades en código AI-generated

La adopción es masiva pero la confianza es mínima. Y la confianza baja no es por mala calidad del código — es por falta de proceso para evaluarlo.

Vocabulario Clave

Antes de avanzar, asegúrate de conocer estos términos que usarás a lo largo de toda la guía:

TérminoDefinición
AI-generated codeCódigo producido por un modelo de lenguaje (Claude Code, Copilot, etc.) en respuesta a un prompt o instrucción
Code hallucinationCódigo que se ve sintácticamente correcto pero contiene errores factuales: imports inexistentes, APIs inventadas, parámetros falsos
Confianza calibradaAjustar tu nivel de confianza y profundidad de revisión según el tipo de tarea, el riesgo de error, y la facilidad de verificación
Code churnCódigo que se escribe y se reescribe rápidamente — un indicador de que el código original no era correcto
Red/Yellow/Green ZoneFramework de 3 niveles que clasifica código AI según el riesgo: Red (revisar exhaustivamente), Yellow (revisar lo importante), Green (aceptar con visual rápido)
Circuit BreakerPunto de pausa obligatorio en tu workflow donde verificas el código AI antes de continuar. Lo verás en detalle en el Módulo 2
Trust CalibrationProceso de ajustar tu confianza por tipo de tarea. No confías igual en un CRUD endpoint que en auth logic. Módulo 2 lo profundiza

No necesitas memorizarlos ahora. Los irás internalizando a medida que los uses en ejercicios concretos.

El Contexto de la Industria

¿Por qué ahora?

La validación de código AI no era un skill hace 3 años. Hoy es una competencia profesional. Esto no es una opinión — es un reflejo de cómo cambió la ingeniería de software:

2022: GitHub Copilot sale de beta → los developers empiezan a experimentar
2023: ChatGPT/Claude generan código complejo → adopción masiva en empresas
2024: AI genera 30%+ del código nuevo en equipos que usan herramientas
2025: Las primeras regulaciones exigen auditoría de código AI-generated
2026: Validar código AI es tan básico como escribir tests

Si no tienes un proceso para evaluar código AI, estás operando con una herramienta poderosa sin manual de seguridad.

Casos reales

Estos son ejemplos documentados de problemas con código AI-generated:

  • Security: Un developer aceptó código generado con hashlib.md5(password) en lugar de bcrypt. El código funcionaba, los tests pasaban, y el hash se almacenaba en la base de datos. El problema: MD5 no es un algoritmo seguro para contraseñas. Fue encontrado 3 meses después en una auditoría de seguridad.

  • Logic: AI generó una función de paginación con offset = page * size. Para page=1, size=10, el offset era 10 — saltándose los primeros 10 resultados. La primera página siempre estaba vacía. El bug vivió 2 semanas en producción porque nadie verificó la lógica de paginación.

  • Hallucination: AI usó requests.get(url, verify_ssl=True). El parámetro correcto es verify=True. El código no fallaba (verify_ssl se ignoraba silenciosamente), pero la verificación SSL no se estaba ejecutando.

Estos no son errores de developers novatos. Son errores de developers competentes que confiaron sin verificar las zonas de riesgo.

Autodiagnóstico: ¿Dónde Estás 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 Claude Code genera un endpoint, ¿qué haces primero?

  • (a) Lo ejecuto para ver si funciona
  • (b) Leo el código completo línea por línea
  • (c) Reviso seguridad y lógica de negocio, confío en el boilerplate
  • (d) Depende de cuánta prisa tenga

2. ¿Recuerdas la última vez que rechazaste output de Claude Code?

  • (a) No, generalmente acepto todo
  • (b) Sí, rechazo frecuentemente
  • (c) Sí, cuando detecté un problema específico
  • (d) No estoy seguro

3. ¿Tienes un checklist o proceso para revisar código AI?

  • (a) No, reviso por instinto
  • (b) Tengo uno mental pero no documentado
  • (c) Sí, tengo un proceso claro
  • (d) Nunca me lo planteé

4. ¿Alguna vez código AI-generated causó un problema en tu proyecto?

  • (a) No que yo sepa (puede que sí pero no lo detecté)
  • (b) Sí, y desde entonces no confío
  • (c) Sí, y ajusté mi proceso de revisión
  • (d) No uso AI para código importante

5. ¿Cómo describes tu relación con AI coding tools?

  • (a) "Me acelera mucho, acepto casi todo"
  • (b) "No confío, prefiero escribir yo"
  • (c) "Las uso con criterio, sé cuándo confiar"
  • (d) "Estoy experimentando, no tengo criterio claro"

Interpretación

  • Mayoría de (a): Estás en el extremo de "aceptar todo". Este módulo te dará estructura.
  • Mayoría de (b): Estás en el extremo de "rechazar todo". Este módulo te mostrará cómo confiar con criterio.
  • Mayoría de (c): Ya tienes una base. Este módulo la refinará y formalizará.
  • Mayoría de (d): Estás en el punto perfecto para empezar. Sin hábitos malos que corregir.

No importa dónde estés — lo que importa es que al terminar este módulo tendrás un framework concreto.

Objetivo Profesional

Al final de este módulo podrás:

  • ✅ Explicar con datos por qué la confianza en AI-generated code es un tema relevante
  • ✅ Identificar en qué extremo te encuentras (aceptar todo vs rechazar todo)
  • ✅ Definir "confianza calibrada" y aplicarla como postura profesional
  • ✅ Usar un framework básico de verificación: qué revisar siempre, qué revisar a veces, qué confiar generalmente
  • ✅ Analizar snippets de código AI y asignar nivel de confianza con justificación

Progresión del Módulo

Mapa del Módulo

CápsulaTemaQué aprenderásTipo
02La Estadística del 3%Datos reales, contexto de encuestas, qué preguntaron y a quiénesConceptual
03Dos Extremos PeligrososAceptar todo vs rechazar todo — por qué ambos son erroresConceptual + Ejercicios
04Confianza CalibradaEl punto medio profesional: verificar lo que importaTécnica + Ejercicios
05Tu Primer Framework de VerificaciónQué revisar siempre, qué a veces, qué confiar — ejercicio prácticoTécnica + Ejercicio Integrador

Flujo de aprendizaje

Primero entenderás el problema con datos reales — no opiniones, no alarma, sino contexto (cápsula 02). Después verás por qué los dos extremos naturales ("acepto todo" y "rechazo todo") son trampas que reducen tu efectividad (cápsula 03). Con esa claridad, descubrirás el punto medio que usan los profesionales: confianza calibrada por tipo de tarea (cápsula 04). Finalmente, construirás tu primer framework de verificación y lo aplicarás a snippets reales (cápsula 05).

La narrativa del módulo

Cápsula 02: "Hay un problema real" (datos)
      ↓
Cápsula 03: "Los extremos no lo resuelven" (contraste)
      ↓
Cápsula 04: "El punto medio sí" (solución)
      ↓
Cápsula 05: "Aquí está tu herramienta" (framework + práctica)

Cada cápsula construye sobre la anterior. No saltes — la progresión es intencional.

Conexión con Proyecto

Ejercicio de este módulo

Vas a analizar 3 snippets de código generados por AI y asignar un nivel de confianza justificado a cada uno. No es un ejercicio artificial — es exactamente lo que haces (o deberías hacer) cada vez que Claude Code genera código para ti.

Los 3 snippets representan diferentes niveles de riesgo:

  • Snippet A: Utilidad de bajo riesgo (formateo de datos)
  • Snippet B: Función de alto riesgo (transferencia de dinero)
  • Snippet C: Configuración de riesgo medio (logging)

Para cada uno, aplicarás los conceptos del módulo y justificarás tu nivel de confianza.

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

El ejercicio de este módulo es la versión mínima de lo que harás en el proyecto integrador. Aquí calibras confianza en 3 snippets; en el módulo 8, lo harás con un codebase FastAPI completo con 15-20 problemas plantados. La habilidad que desarrollas aquí es la base de todo lo que sigue.

Módulo 1: Calibras confianza en 3 snippets
Módulo 3: Detectas hallucinations en 5 snippets
Módulo 4: Code review de un PR completo
Módulo 5: Identificas 5 patrones de error
Módulo 6: Debuggeas una aplicación con bugs
Módulo 8: TODO junto — code review completo de un codebase real

Cada módulo amplifica el skill. Al final del módulo 8, el proceso será natural.

Prerequisitos Técnicos

Para este módulo necesitas:

  • ✅ Claude Code CLI instalado y funcionando (Guías 1-3 completadas)
  • ✅ CLAUDE.md configurado en al menos un proyecto (Guía 4)
  • ✅ Python 3.10+ instalado (para ejecutar ejemplos de código)
  • ✅ FastAPI basics (leer rutas y modelos — el proyecto integrador usa FastAPI)
  • ✅ Git basics (branches, commits — para el flujo de corrección)

No necesitas ser experto en nada. Necesitas poder leer código Python y entender qué hace un endpoint HTTP.

Verificación rápida de setup

Antes de empezar, confirma que tu entorno está listo:

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

# Verifica Claude Code
claude --version
# Esperado: versión instalada

# Verifica que puedes leer FastAPI
python -c "import fastapi; print(f'FastAPI {fastapi.__version__}')"
# Esperado: FastAPI 0.100+

# Verifica pip para instalar dependencias de ejemplos
pip --version
# Esperado: pip 22+

Si algo no funciona, revisa las Guías 1-3 antes de continuar. Este módulo no tiene ejercicios de configuración — asume que tu entorno ya está listo.

Qué nivel de Python necesitas

No necesitas ser developer senior. Necesitas leer y entender código como este:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

class User(BaseModel):
    name: str
    email: str

@app.post("/users")
async def create_user(user: User):
    if user_exists(user.email):
        raise HTTPException(status_code=400, detail="Email exists")
    return save_user(user)

Si puedes leer ese snippet y entender qué hace (crea un usuario, valida con Pydantic, lanza error si el email ya existe), estás listo para este módulo.

Límites: Qué NO Se Cubre en Este Módulo

  • ❌ Técnicas específicas de code review — Eso es el módulo 4. Aquí construyes awareness y frameworks mentales, no checklists detallados.
  • ❌ Cómo detectar hallucinations — Eso es el módulo 3. Aquí entiendes el problema general; el módulo 3 te da la habilidad de detectar el error más peligroso.
  • ❌ Debugging con Claude Code — Eso es el módulo 6. Aquí no vas a escribir código ni debuggear — es un módulo conceptual con un ejercicio de análisis.
  • ❌ Opiniones sobre si AI es "buena" o "mala" — Esta guía es pragmática. AI es una herramienta. La pregunta no es filosófica sino práctica: cómo usarla con rigor profesional.
  • ❌ Comparación entre herramientas de AI — No evaluamos Claude Code vs Copilot vs Cursor. El skill de validar código AI es transferible a cualquier herramienta.

Evidencia de Éxito

Al terminar este módulo, sabrás que tuviste éxito si:

  • ✅ Puedes explicar la estadística del 3% con contexto (de dónde viene, qué significa, qué no significa)
  • ✅ Identificas cuándo estás cayendo en uno de los dos extremos peligrosos
  • ✅ Defines "confianza calibrada" con tus propias palabras y das un ejemplo concreto
  • ✅ Tienes un framework básico de verificación de 3 niveles (Red/Yellow/Green Zone) que puedes usar mañana
  • ✅ Analizaste 3 snippets y justificaste tu nivel de confianza en cada uno con criterio

Cómo se ve el éxito en la práctica

Antes de este módulo:

Claude Code genera → "Se ve bien" → Acepto → ???

Después de este módulo:

Claude Code genera → ¿Red Zone? Reviso exhaustivamente
                   → ¿Yellow Zone? Reviso lo importante
                   → ¿Green Zone? Acepto con visual rápido

La diferencia no es velocidad — es criterio. Y ese criterio se vuelve automático con práctica. Después de unas semanas usando el framework, la clasificación Red/Yellow/Green ocurre naturalmente mientras lees el output de Claude Code.

Cómo medir tu progreso

Lleva un registro informal durante las primeras 2 semanas de usar el framework. Por cada generación de Claude Code, anota:

  • ¿Qué zona le asigné? (Red/Yellow/Green)
  • ¿Cuánto tiempo le dediqué a la revisión?
  • ¿Encontré algún problema?

Después de 20-30 revisiones, verás patrones: qué tipo de código necesita más atención, dónde Claude Code es confiable, y dónde comete errores repetitivos. Esos patrones son tu calibración personal.

Tiempo Estimado

CápsulaTemaTiempo
01Introducción (esta cápsula)10 min
02La Estadística del 3%15-20 min
03Dos Extremos Peligrosos15-20 min
04Confianza Calibrada15-20 min
05Framework de Verificación + Ejercicio20-25 min
Total75-95 min

El módulo está diseñado para completarse en una sesión. Si necesitas dividirlo, el punto natural de pausa es después de la cápsula 03 (los dos extremos).

Resumen

  • Este módulo establece urgencia y relevancia: hay un problema real con la confianza en AI code
  • Solo el 3% de developers confía altamente en código AI — no por alarmismo, sino porque la mayoría no tiene proceso
  • Los dos extremos (aceptar todo, rechazar todo) son igualmente peligrosos para tu productividad y calidad
  • Confianza calibrada es el punto medio profesional: verificas lo que importa con criterio
  • El módulo sigue una progresión clara: datos → contraste → solución → framework práctico
  • Terminas con un framework de verificación de 3 niveles (Red/Yellow/Green) — algo accionable desde el día 1
  • Todo lo que aprendes aquí es la base para code review profesional (Phase 2) y mastery (Phase 3)
  • El ejercicio integrador (3 snippets) es la versión mínima del proyecto final (codebase completo)

Recursos Adicionales

  1. GitHub Copilot Research — Developer Perceptions - Encuesta de GitHub sobre percepción de developers con AI code
  2. Stack Overflow Developer Survey 2024 — AI Section - Datos de la comunidad sobre confianza y uso de AI coding tools
  3. MIT Technology Review — Managing AI-Generated Code - Perspectiva académica sobre supervisión de código AI
  4. Anthropic — Best Practices for Claude Code - Documentación oficial de Claude Code
  5. Google DeepMind — Code Generation Safety - Investigación sobre seguridad en generación de código
  6. GitClear — Coding on Copilot Report - Análisis de impacto en calidad de código con AI tools

Siguiente cápsula: La Estadística del 3% — datos reales sobre la confianza en AI-generated code.

Debugging & Code Review with Claude Code — Módulo 1, Cápsula 01 Claude Code Agentic Development Path — Guía #6 de 11

Siguiente →La Estadística del 3%