La respuesta corta es no, pero la larga te ahorra horas

Una inspección Fagan completa necesita un moderador, un lector, de dos a cuatro inspectores y el autor. El equipo dedica dos horas a revisar aproximadamente 250 líneas de código a 125 líneas por hora. Eso son de ocho a doce horas-persona para un cambio pequeño.

Un LLM puede leer 250 líneas en menos de un segundo. Puede ejecutar una checklist, señalar patrones sospechosos y generar un registry de defectos antes de que ningún humano abra el archivo.

Eso no significa que pueda sustituir al equipo. Significa que el equipo no debería empezar la reunión hasta que el LLM haya terminado su tarea.

Qué puede hacer un LLM realmente en una inspección Fagan

Las inspecciones Fagan tienen cuatro roles distintos. Cada rol tiene una tarea que se mapea de forma diferente a lo que un LLM puede y no puede hacer.

El moderador planifica la inspección, hace cumplir los criterios de entrada y mantiene la reunión enfocada. Un LLM puede generar una checklist, verificar que los tests pasen antes de la inspección y estimar el tiempo en función del conteo de líneas. No puede darse cuenta de que una sala llena de ingenieros está derivando hacia un debate de diseño. El rol de moderador es social, y los LLMs no son sociales.

El lector parafrasea el código en voz alta durante la reunión para obligar al grupo a procesar la lógica a velocidad de comprensión en lugar de velocidad de lectura rápida. Un LLM puede resumir código, pero no puede hacer que una sala de humanos se detenga. El valor real del lector es la imposición social. El LLM no tiene palanca.

Los inspectores encuentran defectos examinando el código contra checklist y conocimiento de dominio. Aquí es donde el LLM es más útil. Puede verificar null dereferences, fugas de recursos, rutas de error no manejadas y errores off-by-one más rápido que cualquier humano. No se cansa. No se salta las funciones de utilidad aburridas porque parecen seguras.

El autor responde preguntas y corrige defectos. El LLM no puede sustituir al autor porque no escribió el código y no puede verificar la intención.

Así que la respuesta realista no es sustitución. Es sustitución de rol. El LLM puede servir como un pre-inspector incansable que maneja las partes mecánicas del rol de inspector antes de que los humanos entren a la sala.

Dónde ayudan realmente los LLMs: la fase de preparación

La fase más importante de una inspección Fagan es la preparación. Cada inspector revisa el material solo antes de la reunión. Los estudios muestran que la preparación encuentra aproximadamente la mitad de los defectos descubiertos en el proceso completo. Si el LLM puede potenciar esa fase, la reunión humana se vuelve más corta y más precisa.

Aquí hay un enfoque práctico. Alimenta al LLM con el código, una checklist adaptada a tu lenguaje y un prompt que fuerce una salida estructurada. Usa la salida del LLM como punto de partida para los inspectores humanos, no como sustituto.

El prompt importa más que el modelo. Una solicitud vaga como “revisa este código” te dará lugares comunes genéricos. Un prompt estructurado con una checklist y formato de salida te dará defectos accionables.

A continuación se muestra un script de Python que ejecuta una pre-inspección basada en LLM usando una API compatible con OpenAI. Lee un archivo fuente, aplica una checklist al estilo Fagan y genera un registry de defectos estructurado.

#!/usr/bin/env python3
"""
LLM pre-inspection for Fagan-style review.
Produces structured defect log from a checklist.
"""

import argparse
import os
from pathlib import Path


def build_prompt(code: str, filepath: str, language: str) -> str:
    checklist = {
        "python": [
            "Missing null/None checks before dereferencing",
            "Unclosed file handles or missing context managers",
            "Bare except clauses that swallow exceptions",
            "Mutable default arguments in function signatures",
            "Race conditions in shared mutable state",
            "Missing input validation on public functions",
        ],
        "typescript": [
            "Non-null assertions (e.g., !) without justification",
            "Missing await on async calls",
            "Any types that should be narrowed",
            "Unhandled promise rejections",
            "Missing input validation on public functions",
        ],
        "rust": [
            "Unwrap or expect without comment explaining invariants",
            "Missing error propagation where Result is returned",
            "Unsafe blocks without safety comments",
            "Clone on large data structures in hot paths",
            "Missing input validation on public functions",
        ],
    }

    items = checklist.get(language, checklist["python"])
    checklist_text = "\n".join(f"  - {item}" for item in items)

    return (
        "You are a Fagan inspection assistant. Review the following code "
        "against the checklist. For each defect found, output a JSON object "
        "with keys: line, category, severity (minor/major/critical), description. "
        "If no defect is found for a checklist item, omit it. "
        "Be specific about line numbers and exact variable names. "
        "Do not suggest fixes. Fagan inspections only log defects, they do not solve them.\n\n"
        f"File: {filepath}\n"
        f"Language: {language}\n\n"
        "Checklist:\n"
        f"{checklist_text}\n\n"
        "Code:\n```\n"
        f"{code}\n"
        "```\n\n"
        "Output strict JSON array of defects only. No markdown, no preamble."
    )


def inspect_file(filepath: str, api_key: str, base_url: str) -> list:
    """Run LLM pre-inspection and return parsed defect list."""
    from openai import OpenAI

    path = Path(filepath)
    code = path.read_text()

    # Infer language from extension
    ext_map = {
        ".py": "python",
        ".ts": "typescript",
        ".tsx": "typescript",
        ".rs": "rust",
    }
    language = ext_map.get(path.suffix, "python")

    client = OpenAI(api_key=api_key, base_url=base_url)
    response = client.chat.completions.create(
        model=os.environ.get("INSPECTION_MODEL", "gpt-4.1-mini"),
        messages=[
            {"role": "system", "content": "You are a precise code inspection tool."},
            {"role": "user", "content": build_prompt(code, filepath, language)},
        ],
        temperature=0.2,
        max_tokens=2048,
    )

    raw = response.choices[0].message.content.strip()

    # Some models wrap JSON in markdown fences. Strip them.
    if raw.startswith("```json"):
        raw = raw[7:]
    if raw.startswith("```"):
        raw = raw[3:]
    if raw.endswith("```"):
        raw = raw[:-3]
    raw = raw.strip()

    import json
    try:
        defects = json.loads(raw)
        if not isinstance(defects, list):
            return []
        return defects
    except json.JSONDecodeError:
        print("Warning: LLM returned non-JSON output:")
        print(raw[:500])
        return []


def main():
    parser = argparse.ArgumentParser(description="LLM pre-inspection for Fagan review")
    parser.add_argument("files", nargs="+", help="Source files to pre-inspect")
    parser.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY"))
    parser.add_argument(
        "--base-url",
        default=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
    )
    args = parser.parse_args()

    if not args.api_key:
        raise SystemExit("Error: set OPENAI_API_KEY or pass --api-key")

    all_defects = []
    for f in args.files:
        defects = inspect_file(f, args.api_key, args.base_url)
        all_defects.extend({"file": f, **d} for d in defects)

    if not all_defects:
        print("No defects flagged by LLM pre-inspection.")
        return

    print(f"LLM pre-inspection found {len(all_defects)} defect(s):\n")
    for d in all_defects:
        print(
            f"[{d['severity'].upper()}] {d['file']}:{d.get('line', '?')} "
            f"({d['category']}) {d['description']}"
        )


if __name__ == "__main__":
    main()

Instala el SDK de OpenAI con pip install openai, configura tu API key y ejecuta python inspect.py src/auth.py. El script genera un registro de defectos estructurado que los inspectores humanos pueden usar como su checklist inicial.

Esto no es la inspección. Es la preparación. Los defectos aún necesitan juicio humano.

Qué se les escapa a los LLMs: los defectos que cuestan dinero real

Los defectos más costosos no son errores de sintaxis. Son suposiciones incorrectas.

Un LLM detectará el null check faltante. No detectará que el caso null nunca debería ocurrir porque el servicio upstream garantiza el campo, y el bug real es que tu equipo cambió el contrato hace tres semanas y olvidó actualizar el código downstream.

Un LLM marcará una excepción no manejada. No notará que falta el exception handler porque el autor asumió que la transacción de base de datos haría rollback automáticamente, y esa suposición es falsa para el nivel de aislamiento específico que usa tu equipo.

Estos son defectos a nivel de intención. Requieren conocimiento de dominio, contexto histórico y la capacidad de preguntar “¿qué asumió el autor que no es cierto?” Un LLM no tiene acceso a las suposiciones no documentadas de tu equipo. No tiene memoria de la decisión de arquitectura del trimestre pasado. No puede mirar un documento de requisitos y notar que el código implementa el requisito equivocado.

Las inspecciones Fagan fueron diseñadas para detectar exactamente estos defectos. Los inspectores humanos aportan diferentes modelos mentales y diferentes contextos. Cuando discrepan sobre lo que el código debería hacer, la brecha entre sus suposiciones es donde viven los bugs reales.

Un LLM tiene un solo modelo mental, y está entrenado en código público, no en tu codebase.

El verdadero trade-off: cobertura vs. comprensión

La pre-inspección con LLM te da cobertura. Lee cada línea, revisa cada función y nunca se distrae con una notificación de Slack. Es el inspector estrecho perfecto.

La inspección humana te da comprensión. Conecta el código con la especificación, la especificación con el esquema de base de datos y el esquema con la regla de negocio que cambió en la última reunión de sprint planning. Es la única forma de encontrar defectos que viven fuera del código.

El trade-off no es humano versus máquina. Es profundo versus amplio.

Si reemplazas tu equipo de inspección por un LLM, encontrarás más defectos a nivel de sintaxis y perderás más defectos a nivel de intención. El resultado neto depende de qué tipo de bugs te están matando. Si tus incidentes en producción son mayormente null dereferences y fugas de recursos, un LLM ayudará. Si tus incidentes son mayormente lógica de negocio incorrecta y casos edge omitidos, un LLM te dará una falsa confianza.

Cómo ejecutar una inspección híbrida en la práctica

Aquí hay un workflow práctico que usa el LLM para lo que hace bien y preserva al equipo humano para lo que solo los humanos pueden hacer.

Antes de la reunión, ejecuta el script de pre-inspección con LLM sobre el código. Dale a cada inspector humano la salida más el código original. Exígele que verifique o descarte cada hallazgo del LLM durante su preparación individual. Esto los obliga a examinar líneas que de otro modo habrían pasado por alto.

Durante la reunión, el lector sigue parafraseando el código en voz alta. Los inspectores siguen planteando problemas. Pero ahora parten de una lista curada de defectos mecánicos ya triageados. El tiempo de reunión puede reducirse de dos horas a noventa minutos, o el equipo puede revisar más código en la misma ventana de tiempo.

El moderador suma una nueva responsabilidad: rastrear la precisión del LLM. Registra cuántos defectos señalados por el LLM eran reales, cuántos eran falsos positivos y cuántos defectos exclusivamente humanos se le escaparon al LLM. Después de tres o cuatro inspecciones, sabrás si tu prompt de checklist necesita ajuste.

Este es el mismo proceso que usó la NASA cuando experimentaron con inspección asistida por herramientas en los años noventa. Los verificadores automatizados encontraron los defectos fáciles y dejaron los difíciles para los humanos. Los humanos rindieron mejor porque no estaban mentalmente exhaustos de encontrar los fáciles.

La conclusión

Un LLM no puede sustituir a un equipo de inspección completo porque la inspección no es solo leer código. Es un proceso social estructurado diseñado para sacar a la superficie las brechas entre lo que el autor asumió y lo que el código realmente hace.

Lo que un LLM sí puede hacer es hacer al equipo humano más efectivo eliminando la carga mecánica. Puede desempeñar un quinto rol: el pre-inspector incansable que prepara el campo de batalla antes de que lleguen los humanos.

Si estás omitiendo inspecciones porque son demasiado costosas, un LLM no las hace gratis. Las hace más cortas. Eso suele ser suficiente.

FAQ

¿Qué es una inspección Fagan?

Un proceso de revisión estructurado de seis fases inventado por Michael Fagan en IBM en 1976. Utiliza roles definidos (moderador, lector, inspectores, autor), preparación individual obligatoria y reuniones con tiempo limitado para encontrar defectos antes de las pruebas. Reporta consistentemente tasas de eliminación de defectos del 60 al 90 por ciento.

¿Puede un LLM sustituir a un revisor de código humano?

No para los defectos que más importan. Un LLM atrapa problemas mecánicos como null checks faltantes y fugas de recursos. Se pierde defectos a nivel de intención como suposiciones incorrectas sobre contratos upstream, lógica de negocio faltante y desajustes entre código y requisitos.

¿Cómo integras un LLM en una inspección Fagan?

Usa el LLM durante la fase de preparación. Ejecútalo contra una checklist, alimenta su salida a los inspectores humanos antes de la reunión y exige que verifiquen cada hallazgo. Esto acorta la reunión y mejora el enfoque humano sin eliminar el juicio humano.

¿Qué hace efectivo a un prompt de checklist para LLM?

La especificidad. Los prompts genéricos producen salida genérica. Los prompts efectivos nombran categorías de defectos exactas, exigen salida JSON estructurada, prohíben propuestas de solución y piden números de línea exactos y nombres de variables. La checklist debe coincidir con tu lenguaje y los defectos más comunes que escapa tu equipo.

Pruébalo en un archivo

Elige un archivo que causó un incidente en producción el mes pasado. Escribe una checklist de cinco tipos de defectos específicos que le importen a tu equipo. Ejecuta el script anterior con esa checklist. Dale la salida a dos ingenieros que no escribieron el archivo.

Compara los hallazgos del LLM con los hallazgos humanos. Cuenta la superposición. Cuenta lo que cada lado omitió. Esa brecha es tu respuesta.