Método do Papai Noel

O que Método do Papai Noel faz?

Estrutura de verificação adversarial multiagente. Faça uma lista, verifique duas vezes. Se estiver ruim, corrija até ficar bom.

A percepção central: um único agente revisando sua própria saída compartilha os mesmos vieses, lacunas de conhecimento e erros sistemáticos que produziram a saída. Dois revisores independentes, sem contexto compartilhado, quebram esse modo de falha.

Quando Ativar

Invoque esta habilidade quando:

• A saída for publicada, implantada ou consumida por usuários finais
• Restrições de conformidade, regulatórias ou de marca precisarem ser aplicadas
• Código for enviado para produção sem revisão humana
• A precisão do conteúdo for importante (documentação técnica, material educacional, texto voltado para o cliente)
• Geração em lote em grande escala, onde a verificação por amostragem perde padrões sistêmicos
• O risco de alucinação for elevado (afirmações, estatísticas, referências de API, linguagem jurídica)

NÃO use para rascunhos internos, pesquisa exploratória ou tarefas com verificação determinística (use pipelines de build/teste/lint para essas).

Arquitetura

┌─────────────┐
│  GERADOR     │  Fase 1: Faça uma Lista
│  (Agente A)  │  Produza a entrega
└──────┬───────┘
       │ saída
       ▼
┌──────────────────────────────┐
│     REVISÃO DUPLA INDEPENDENTE │  Fase 2: Verifique Duas Vezes
│                                │
│  ┌───────────┐ ┌───────────┐  │  Dois agentes, mesma rubrica,
│  │ Revisor B │ │ Revisor C │  │  sem contexto compartilhado
│  └─────┬─────┘ └─────┬─────┘  │
│        │              │        │
└────────┼──────────────┼────────┘
         │              │
         ▼              ▼
┌──────────────────────────────┐
│      PORTÃO DE VEREDITO       │  Fase 3: Ruim ou Bom
│                                │
│  B aprova E C aprova → BOM     │  Ambos devem aprovar.
│  Caso contrário → RUIM         │  Sem exceções.
└──────┬──────────────┬─────────┘
       │              │
    BOM             RUIM
       │              │
       ▼              ▼
   [ ENVIAR ]    ┌─────────────┐
                  │  CICLO DE    │  Fase 4: Corrija Até Ficar Bom
                  │  CORREÇÃO    │
                  │              │
                  │ iteração++  │  Colete todas as flags.
                  │ se i > MAX: │  Corrija todos os problemas.
                  │   escalar   │  Reexecute ambos os revisores.
                  │ senão:      │  Loop até convergência.
                  │   vá p/ F.2│
                  └──────────────┘

Detalhes das Fases

Fase 1: Faça uma Lista (Gerar)

Execute a tarefa principal. Nenhuma alteração no seu fluxo normal de geração. O Método do Papai Noel é uma camada de verificação pós-geração, não uma estratégia de geração.

# O gerador roda normalmente
saida = gerar(especificacao_tarefa)

Fase 2: Verifique Duas Vezes (Revisão Dupla Independente)

Crie dois agentes revisores em paralelo. Invariantes críticos:

1. Isolamento de contexto — nenhum revisor vê a avaliação do outro
2. Rubrica idêntica — ambos recebem os mesmos critérios de avaliação
3. Mesmas entradas — ambos recebem a especificação original E a saída gerada
4. Saída estruturada — cada um retorna um veredito tipado, não prosa

PROMPT_REVISOR = """Você é um revisor de qualidade independente. Você NÃO viu nenhuma outra revisão desta saída.

## Especificação da Tarefa
{especificacao_tarefa}

## Saída em Revisão
{saida}

## Rubrica de Avaliação
{rubrica}

## Instruções
Avalie a saída contra CADA critério da rubrica. Para cada:
- APROVADO: critério totalmente atendido, sem problemas
- REPROVADO: problema específico encontrado (cite o problema exato)

Retorne sua avaliação como JSON estruturado:
{
  "veredito": "APROVADO" | "REPROVADO",
  "verificacoes": [
    {"criterio": "...", "resultado": "APROVADO|REPROVADO", "detalhe": "..."}
  ],
  "problemas_criticos": ["..."],   // bloqueadores que devem ser corrigidos
  "sugestoes": ["..."]              // melhorias não bloqueantes
}

Seja rigoroso. Seu trabalho é encontrar problemas, não aprovar.
"""

# Crie revisores em paralelo (subagentes Claude Code)
revisor_b = Agente(prompt=PROMPT_REVISOR.format(...), descricao="Revisor B do Papai Noel")
revisor_c = Agente(prompt=PROMPT_REVISOR.format(...), descricao="Revisor C do Papai Noel")

# Ambos executam concorrentemente — nenhum vê o outro

Projeto da Rubrica

A rubrica é a entrada mais importante. Rubricas vagas produzem revisões vagas. Cada critério deve ter uma condição objetiva de aprovação/reprovação.

Critério	Condição de Aprovação	Sinal de Falha
Exatidão factual	Todas as afirmações verificáveis contra material de origem ou conhecimento comum	Estatísticas inventadas, números de versão errados, APIs inexistentes
Livre de alucinações	Nenhuma entidade, citação, URL ou referência fabricada	Links para páginas que não existem, citações atribuídas sem fonte
Completeza	Cada requisito na especificação é abordado	Seções faltando, casos de borda ignorados, cobertura incompleta
Conformidade	Passa em todas as restrições específicas do projeto	Termos proibidos usados, violações de tom, não conformidade regulatória
Consistência interna	Nenhuma contradição dentro da saída	Seção A diz X, seção B diz não-X
Correção técnica	Código compila/executa, algoritmos são sólidos	Erros de sintaxe, bugs de lógica, alegações de complexidade erradas

Extensões de Rubrica Específicas por Domínio

Conteúdo/Marketing:

• Aderência à voz da marca
• Requisitos de SEO atendidos (densidade de palavras-chave, meta tags, estrutura)
• Nenhum uso indevido de marca registrada de concorrentes
• CTA presente e linkado corretamente

Código:

• Segurança de tipos (sem vazamentos de any, tratamento adequado de nulos)
• Cobertura de tratamento de erros
• Segurança (sem segredos no código, validação de entrada, prevenção de injeção)
• Cobertura de testes para novos caminhos

Sensível a Conformidade (regulado, jurídico, financeiro):

• Nenhuma garantia de resultado ou afirmação não fundamentada
• Isenções de responsabilidade obrigatórias presentes
• Apenas terminologia aprovada
• Linguagem apropriada para a jurisdição

Fase 3: Ruim ou Bom (Portão de Veredito)

def veredito_papai_noel(revisao_b, revisao_c):
    """Ambos os revisores devem aprovar. Sem crédito parcial."""
    if revisao_b.veredito == "APROVADO" and revisao_c.veredito == "APROVADO":
        return "BOM"  # Envie

    # Mescle flags de ambos os revisores, deduplicando
    todos_problemas = deduplicar(revisao_b.problemas_criticos + revisao_c.problemas_criticos)
    todas_sugestoes = deduplicar(revisao_b.sugestoes + revisao_c.sugestoes)

    return "RUIM", todos_problemas, todas_sugestoes

Por que ambos devem aprovar: se apenas um revisor detecta um problema, esse problema é real. O ponto cego do outro revisor é exatamente o modo de falha que o Método do Papai Noel existe para eliminar.

Fase 4: Corrija Até Ficar Bom (Loop de Convergência)

MAX_ITERACOES = 3

for iteracao in range(MAX_ITERACOES):
    veredito, problemas, sugestoes = veredito_papai_noel(revisao_b, revisao_c)

    if veredito == "BOM":
        registrar_resultado_papai_noel(saida, iteracao, "aprovado")
        return enviar(saida)

    # Corrija todos os problemas críticos (sugestões são opcionais)
    saida = agente_correcao.executar(
        saida=saida,
        problemas=problemas,
        instrucao="Corrija APENAS os problemas sinalizados. Não refatore ou adicione alterações não solicitadas."
    )

    # Reexecute AMBOS os revisores na saída corrigida (agentes novos, sem memória da rodada anterior)
    revisao_b = Agente(prompt=PROMPT_REVISOR.format(saida=saida, ...))
    revisao_c = Agente(prompt=PROMPT_REVISOR.format(saida=saida, ...))

# Iterações esgotadas — escalar
registrar_resultado_papai_noel(saida, MAX_ITERACOES, "escalado")
escalar_para_humano(saida, problemas)

Crítico: cada rodada de revisão usa agentes novos. Os revisores não devem carregar memória das rodadas anteriores, pois o contexto anterior cria viés de ancoragem.

Padrões de Implementação

Padrão A: Subagentes Claude Code (Recomendado)

Subagentes fornecem verdadeiro isolamento de contexto. Cada revisor é um processo separado, sem estado compartilhado.

# Em uma sessão Claude Code, use a ferramenta Agent para criar revisores
# Ambos os agentes executam em paralelo para velocidade

# Pseudocódigo para invocação da ferramenta Agent
revisor_b = Agente(
    descricao="Revisor B do Papai Noel",
    prompt=f"Revise esta saída quanto à qualidade...\n\nRUBRICA:\n{rubrica}\n\nSAÍDA:\n{saida}"
)
revisor_c = Agente(
    descricao="Revisor C do Papai Noel",
    prompt=f"Revise esta saída quanto à qualidade...\n\nRUBRICA:\n{rubrica}\n\nSAÍDA:\n{saida}"
)

Padrão B: Sequencial Inline (Alternativa)

Quando subagentes não estiverem disponíveis, simule isolamento com redefinições explícitas de contexto:

1. Gere a saída
2. Novo contexto: "Você é o Revisor 1. Avalie APENAS contra esta rubrica. Encontre problemas."
3. Registre os achados literalmente
4. Limpe o contexto completamente
5. Novo contexto: "Você é o Revisor 2. Avalie APENAS contra esta rubrica. Encontre problemas."
6. Compare ambas as revisões, corrija, repita

O padrão de subagentes é estritamente superior — a simulação inline corre risco de vazamento de contexto entre revisores.

Padrão C: Amostragem em Lote

Para lotes grandes (100+ itens), aplicar o método completo em cada item é proibitivo em custo. Use amostragem estratificada:

1. Execute o método em uma amostra aleatória (10-15% do lote, mínimo 5 itens)
2. Categorize as falhas por tipo (alucinação, conformidade, completeza, etc.)
3. Se padrões sistemáticos surgirem, aplique correções direcionadas a todo o lote
4. Re-amostre e re-verifique o lote corrigido
5. Continue até que uma amostra limpa passe

import random

def lote_papai_noel(itens, rubrica, taxa_amostragem=0.15):
    amostra = random.sample(itens, max(5, int(len(itens) * taxa_amostragem)))

    for item in amostra:
        resultado = metodo_completo(item, rubrica)
        if resultado.veredito == "RUIM":
            padrao = classificar_falha(resultado.problemas)
            itens = corrigir_lote(itens, padrao)  # Corrige todos os itens que correspondem ao padrão
            return lote_papai_noel(itens, rubrica)   # Re-amostra

    return itens  # Amostra limpa → enviar lote

Modos de Falha e Mitigações

Modo de Falha	Sintoma	Mitigação
Loop infinito	Revisores continuam encontrando novos problemas após correções	Limite máximo de iterações (3). Escalar.
Aprovação automática	Ambos os revisores aprovam tudo	Prompt adversarial: "Seu trabalho é encontrar problemas, não aprovar."
Deriva subjetiva	Revisores sinalizam preferências de estilo, não erros	Rubrica restrita com critérios objetivos de aprovação/reprovação apenas
Regressão de correção	Corrigir o problema A introduz o problema B	Revisores novos a cada rodada capturam regressões
Viés de concordância entre revisores	Ambos os revisores perdem a mesma coisa	Mitigado pela independência, não eliminado. Para saída crítica, adicione um terceiro revisor ou verificação humana por amostragem.
Explosão de custo	Muitas iterações em saídas grandes	Padrão de amostragem em lote. Limites de orçamento por ciclo de verificação.

Integração com Outras Habilidades

Habilidade	Relação
Loop de Verificação	Use para verificações determinísticas (build, lint, teste). Use o Método do Papai Noel para verificações semânticas (exatidão, alucinações). Execute o loop de verificação primeiro, depois o Método do Papai Noel.
Eval Harness	Os resultados do Método do Papai Noel alimentam métricas de avaliação. Acompanhe pass@k nas execuções do método para medir a qualidade do gerador ao longo do tempo.
Aprendizado Contínuo v2	Os achados do método tornam-se intuições. Falhas repetidas no mesmo critério → comportamento aprendido para evitar o padrão.
Compacto Estratégico	Execute o método ANTES de compactar. Não perca contexto de revisão no meio da verificação.

Métricas

Acompanhe estas para medir a eficácia do Método do Papai Noel:

• Taxa de primeira aprovação: % de saídas que passam no método na rodada 1 (meta: >70%)
• Média de iterações até convergência: rodadas médias até BOM (meta: <1.5)
• Taxonomia de problemas: distribuição dos tipos de falha (alucinação vs. completeza vs. conformidade)
• Concordância entre revisores: % de problemas sinalizados por ambos os revisores vs. apenas um (baixa concordância = rubrica precisa ser ajustada)
• Taxa de escape: problemas encontrados após o envio que o método deveria ter capturado (meta: 0)

Análise de Custo

O Método do Papai Noel custa aproximadamente 2 a 3 vezes o custo de token da geração sozinha por ciclo de verificação. Para a maioria das saídas de alto risco, isso é um custo-benefício:

Custo do Método = (tokens de geração) + 2×(tokens de revisão por rodada) × (média de rodadas)
Custo de NÃO usar o Método = (dano à reputação) + (esforço de correção) + (erosão da confiança)

Para operações em lote, o padrão de amostragem reduz o custo para ~15-20% da verificação completa, enquanto captura mais de 90% dos problemas sistemáticos.