método-santa

Método Santa

Marco de verificación adversarial multiagente. Haz una lista, revísala dos veces. Si es traviesa, arréglala hasta que sea buena.

La idea central: un único agente revisando su propio resultado comparte los mismos sesgos, lagunas de conocimiento y errores sistemáticos que produjeron dicho resultado. Dos revisores independientes sin contexto compartido rompen este modo de fallo.

Cuándo activarlo

Invoca esta skill cuando:

• El resultado se vaya a publicar, desplegar o consumir por usuarios finales
• Se deban cumplir restricciones de cumplimiento normativo, regulatorias o de marca
• El código se envíe a producción sin revisión humana
• La precisión del contenido sea importante (documentación técnica, material educativo, textos para clientes)
• Se generen lotes a gran escala donde el muestreo aleatorio pasa por alto patrones sistemáticos
• El riesgo de alucinación sea elevado (afirmaciones, estadísticas, referencias a APIs, lenguaje legal)

NO la uses para borradores internos, investigación exploratoria o tareas con verificación determinista (usa pipelines de compilación/pruebas/lint para esas).

Arquitectura

┌─────────────┐
│  GENERADOR   │  Fase 1: Haz una lista
│  (Agente A)   │  Produce el entregable
└──────┬───────┘
       │ salida
       ▼
┌──────────────────────────────┐
│     REVISIÓN DUAL INDEPENDIENTE  │  Fase 2: Revísala dos veces
│                                │
│  ┌───────────┐ ┌───────────┐  │  Dos agentes, misma rúbrica,
│  │ Revisor B │ │ Revisor C │  │  sin contexto compartido
│  └─────┬─────┘ └─────┬─────┘  │
│        │              │        │
└────────┼──────────────┼────────┘
         │              │
         ▼              ▼
┌──────────────────────────────┐
│     PUERTA DE VEREDICTO       │  Fase 3: ¿Traviesa o buena?
│                                │
│  ¿B aprueba Y C aprueba? → BUENA  │  Ambas deben aprobar.
│  De lo contrario → TRAVIESA        │  Sin excepciones.
└──────┬──────────────┬─────────┘
       │              │
    BUENA           TRAVIESA
       │              │
       ▼              ▼
   [ ENVIAR ]    ┌─────────────┐
                 │  CICLO DE    │  Fase 4: Arrégiala hasta
                 │  CORRECCIÓN  │  que sea buena
                 │              │
                 │ iteración++  │  Recoge todas las banderas.
                 │ si i > MAX:  │  Corrige todos los problemas.
                 │   escalar    │  Vuelve a ejecutar ambos revisores.
                 │ sino:        │  Bucle hasta convergencia.
                 │   ir a Fase 2│
                 └──────────────┘

Detalles de las fases

Fase 1: Haz una lista (Generar)

Ejecuta la tarea principal. Sin cambios en tu flujo de trabajo de generación normal. El método Santa es una capa de verificación posterior a la generación, no una estrategia de generación.

# El generador funciona con normalidad
salida = generar(especificacion_tarea)

Fase 2: Revísala dos veces (Revisión dual independiente)

Genera dos agentes de revisión en paralelo. Invariantes críticos:

1. Aislamiento de contexto — ningún revisor ve la evaluación del otro
2. Rúbrica idéntica — ambos reciben los mismos criterios de evaluación
3. Mismos insumos — ambos reciben la especificación original Y la salida generada
4. Salida estructurada — cada uno devuelve un veredicto con tipo, no texto libre

PROMPT_REVISOR = """
Eres un revisor de calidad independiente. NO has visto ninguna otra revisión de esta salida.

## Especificación de la tarea
{especificacion_tarea}

## Salida bajo revisión
{salida}

## Rúbrica de evaluación
{rubrica}

## Instrucciones
Evalúa la salida frente a CADA criterio de la rúbrica. Para cada uno:
- APROBADO: criterio cumplido completamente, sin problemas
- SUSPENSO: problema específico encontrado (cita el problema exacto)

Devuelve tu evaluación como JSON estructurado:
{
  "veredicto": "APROBADO" | "SUSPENSO",
  "comprobaciones": [
    {"criterio": "...", "resultado": "APROBADO|SUSPENSO", "detalle": "..."}
  ],
  "problemas_criticos": ["..."],   // bloqueantes que deben corregirse
  "sugerencias": ["..."]           // mejoras no bloqueantes
}

Sé riguroso. Tu trabajo es encontrar problemas, no aprobar.
"""

# Genera revisores en paralelo (subagentes de Claude Code)
revisor_b = Agente(prompt=PROMPT_REVISOR.format(...), descripcion="Revisor Santa B")
revisor_c = Agente(prompt=PROMPT_REVISOR.format(...), descripcion="Revisor Santa C")

# Ambos se ejecutan concurrentemente — ninguno ve al otro

Diseño de la rúbrica

La rúbrica es el insumo más importante. Las rúbricas vagas generan revisiones vagas. Cada criterio debe tener una condición de aprobado/suspendido objetiva.

Criterio	Condición de aprobado	Señal de fallo
Precisión fáctica	Todas las afirmaciones verificables con material fuente o conocimiento común	Estadísticas inventadas, números de versión incorrectos, APIs inexistentes
Sin alucinaciones	Sin entidades, citas, URLs o referencias fabricadas	Enlaces a páginas que no existen, citas atribuidas sin fuente
Integridad	Cada requisito de la especificación está cubierto	Secciones faltantes, casos límite omitidos, cobertura incompleta
Cumplimiento	Supera todas las restricciones específicas del proyecto	Términos prohibidos usados, violaciones de tono, incumplimiento normativo
Consistencia interna	Sin contradicciones dentro de la salida	La sección A dice X, la sección B dice no-X
Corrección técnica	El código compila/ejecuta, los algoritmos son sólidos	Errores de sintaxis, bugs lógicos, afirmaciones de complejidad erróneas

Extensiones de rúbrica por dominio

Contenido/Marketing:

• Adherencia a la voz de marca
• Requisitos SEO cumplidos (densidad de palabras clave, metaetiquetas, estructura)
• Sin uso indebido de marcas registradas de competidores
• Llamada a la acción presente y correctamente enlazada

Código:

• Seguridad de tipos (sin fugas de any, manejo adecuado de nulos)
• Cobertura de manejo de errores
• Seguridad (sin secretos en el código, validación de entrada, prevención de inyección)
• Cobertura de pruebas para nuevas rutas

Con cumplimiento normativo (regulado, legal, financiero):

• Sin garantías de resultados ni afirmaciones no fundamentadas
• Descargos de responsabilidad requeridos presentes
• Solo terminología aprobada
• Lenguaje apropiado para la jurisdicción

Fase 3: ¿Traviesa o buena? (Puerta de veredicto)

def veredicto_santa(revisor_b, revisor_c):
    """Ambos revisores deben aprobar. Sin crédito parcial."""
    if revisor_b.veredicto == "APROBADO" and revisor_c.veredicto == "APROBADO":
        return "BUENA"  # Enviarlo

    # Combinar banderas de ambos revisores, deduplicar
    todos_problemas = deduplicar(revisor_b.problemas_criticos + revisor_c.problemas_criticos)
    todas_sugerencias = deduplicar(revisor_b.sugerencias + revisor_c.sugerencias)

    return "TRAVIESA", todos_problemas, todas_sugerencias

Por qué ambos deben aprobar: si solo un revisor detecta un problema, ese problema es real. El punto ciego del otro revisor es exactamente el modo de fallo que el método Santa existe para eliminar.

Fase 4: Arrégiala hasta que sea buena (Bucle de convergencia)

MAX_ITERACIONES = 3

for iteracion in range(MAX_ITERACIONES):
    veredicto, problemas, sugerencias = veredicto_santa(revisor_b, revisor_c)

    if veredicto == "BUENA":
        registrar_resultado_santa(salida, iteracion, "aprobado")
        return enviar(salida)

    # Corregir todos los problemas críticos (las sugerencias son opcionales)
    salida = agente_correccion.ejecutar(
        salida=salida,
        problemas=problemas,
        instruccion="Corrige SOLO los problemas señalados. No refactorices ni añadas cambios no solicitados."
    )

    # Volver a ejecutar AMBOS revisores sobre la salida corregida (agentes nuevos, sin memoria de la ronda anterior)
    revisor_b = Agente(prompt=PROMPT_REVISOR.format(salida=salida, ...))
    revisor_c = Agente(prompt=PROMPT_REVISOR.format(salida=salida, ...))

# Iteraciones agotadas — escalar
registrar_resultado_santa(salida, MAX_ITERACIONES, "escalado")
escalar_a_humano(salida, problemas)

Crítico: cada ronda de revisión usa agentes nuevos. Los revisores no deben tener memoria de rondas anteriores, ya que el contexto previo crea sesgo de anclaje.

Patrones de implementación

Patrón A: Subagentes de Claude Code (Recomendado)

Los subagentes proporcionan un verdadero aislamiento de contexto. Cada revisor es un proceso separado sin estado compartido.

# En una sesión de Claude Code, usa la herramienta Agent para generar revisores
# Ambos agentes se ejecutan en paralelo para mayor rapidez

# Pseudocódigo para invocación de la herramienta Agent
revisor_b = Agente(
    descripcion="Revisor Santa B",
    prompt=f"Revisa esta salida por calidad...\n\nRÚBRICA:\n{rubrica}\n\nSALIDA:\n{salida}"
)
revisor_c = Agente(
    descripcion="Revisor Santa C",
    prompt=f"Revisa esta salida por calidad...\n\nRÚBRICA:\n{rubrica}\n\nSALIDA:\n{salida}"
)

Patrón B: Secuencial en línea (Alternativa)

Cuando los subagentes no están disponibles, simula el aislamiento con reinicios de contexto explícitos:

1. Genera la salida
2. Nuevo contexto: "Eres el Revisor 1. Evalúa SOLO frente a esta rúbrica. Encuentra problemas."
3. Registra los hallazgos textualmente
4. Limpia el contexto por completo
5. Nuevo contexto: "Eres el Revisor 2. Evalúa SOLO frente a esta rúbrica. Encuentra problemas."
6. Compara ambas revisiones, corrige, repite

El patrón de subagentes es estrictamente superior: la simulación en línea corre el riesgo de contaminación de contexto entre revisores.

Patrón C: Muestreo por lotes

Para lotes grandes (100+ elementos), aplicar el método Santa completo a cada elemento es prohibitivo. Usa muestreo estratificado:

1. Ejecuta Santa en una muestra aleatoria (10-15% del lote, mínimo 5 elementos)
2. Categoriza los fallos por tipo (alucinación, cumplimiento, integridad, etc.)
3. Si surgen patrones sistemáticos, aplica correcciones dirigidas a todo el lote
4. Vuelve a muestrear y verificar el lote corregido
5. Continúa hasta que una muestra limpia pase

import random

def santa_lote(elementos, rubrica, tasa_muestra=0.15):
    muestra = random.sample(elementos, max(5, int(len(elementos) * tasa_muestra)))

    for elemento in muestra:
        resultado = santa_completo(elemento, rubrica)
        if resultado.veredicto == "TRAVIESA":
            patron = clasificar_fallo(resultado.problemas)
            elementos = corregir_lote(elementos, patron)  # Corregir todos los elementos que coinciden con el patrón
            return santa_lote(elementos, rubrica)           # Volver a muestrear

    return elementos  # Muestra limpia → enviar lote

Modos de fallo y mitigaciones

Modo de fallo	Síntoma	Mitigación
Bucle infinito	Los revisores siguen encontrando nuevos problemas tras las correcciones	Límite máximo de iteraciones (3). Escalar.
Aprobación automática	Ambos revisores aprueban todo	Prompt adversarial: "Tu trabajo es encontrar problemas, no aprobar."
Deriva subjetiva	Los revisores señalan preferencias de estilo, no errores	Rúbrica estricta con criterios de aprobado/suspendido objetivos solamente
Regresión de corrección	Corregir el problema A introduce el problema B	Revisores nuevos en cada ronda detectan regresiones
Sesgo de acuerdo entre revisores	Ambos revisores pasan por alto lo mismo	Mitigado por la independencia, no eliminado. Para salidas críticas, añade un tercer revisor o verificación humana puntual.
Explosión de costes	Demasiadas iteraciones en salidas grandes	Patrón de muestreo por lotes. Límites de presupuesto por ciclo de verificación.

Integración con otras skills

Skill	Relación
Verification Loop	Úsala para verificaciones deterministas (compilación, lint, pruebas). Usa Santa para verificaciones semánticas (precisión, alucinaciones). Ejecuta verification-loop primero, Santa después.
Eval Harness	Los resultados del método Santa alimentan las métricas de evaluación. Realiza un seguimiento de pass@k en las ejecuciones de Santa para medir la calidad del generador a lo largo del tiempo.
Continuous Learning v2	Los hallazgos de Santa se convierten en instintos. Fallos repetidos en el mismo criterio → comportamiento aprendido para evitar el patrón.
Strategic Compact	Ejecuta Santa ANTES de compactar. No pierdas el contexto de revisión en medio de la verificación.

Métricas

Realiza un seguimiento de estas para medir la efectividad del método Santa:

• Tasa de primer pase: % de salidas que pasan Santa en la ronda 1 (objetivo: >70%)
• Media de iteraciones hasta convergencia: rondas promedio hasta BUENA (objetivo: <1.5)
• Taxonomía de problemas: distribución de tipos de fallo (alucinación vs. integridad vs. cumplimiento)
• Acuerdo entre revisores: % de problemas señalados por ambos revisores vs. solo uno (bajo acuerdo = la rúbrica necesita ajuste)
• Tasa de escape: problemas encontrados después del envío que Santa debería haber detectado (objetivo: 0)

Análisis de costes

El método Santa cuesta aproximadamente 2-3 veces el coste de tokens de la generación sola por ciclo de verificación. Para la mayoría de las salidas de alto riesgo, es una ganga:

Coste de Santa = (tokens de generación) + 2×(tokens de revisión por ronda) × (rondas medias)
Coste de NO Santa = (daño a la reputación) + (esfuerzo de corrección) + (pérdida de confianza)

Para operaciones por lotes, el patrón de muestreo reduce el coste a ~15-20% de la verificación completa, mientras detecta >90% de los problemas sistemáticos.