Como verificar respostas da IA antes de confiar

Verificar uma resposta de IA significa transformar um texto convincente numa lista de coisas que podem ser conferidas. Marque afirmações, abra as fontes, refaça contas, compare datas e registre claramente o que ainda não foi provado.

Os exemplos desta lição analisam fixtures escritas para a aula. Elas não são saídas de ChatGPT, Claude, Gemini nem de outro modelo. Todo resultado exibido foi produzido localmente no Node 26.3.0, sem rede ou API. A lição anterior mostra como escolher uma primeira tarefa segura; o que é um LLM explica por que fluência não equivale a acesso automático à verdade.

Primeiro separe afirmação, conselho e formato

Uma resposta pode misturar uma definição verificável, uma recomendação e uma frase de organização. Somente perguntar “está certo?” esconde trabalhos diferentes. Pense numa revisão de código: você não aprova o arquivo pela indentação; observa cada comportamento que pode quebrar.

O analisador abaixo procura sinais que merecem inspeção: números, anos, palavras absolutas e URLs. Ele não decide verdade. Uma frase sem esses sinais também pode estar errada.

function sinaisDaFrase(frase) {
  return {
    numero: /\d/.test(frase),
    data: /\b(?:19|20)\d{2}\b/.test(frase),
    absoluta: /\b(?:sempre|nunca|todos?|nenhum|garante)\b/i.test(frase),
    url: /https?:\/\/\S+/i.test(frase),
  };
}

const fraseLocal = "Em 2026, todo projeto com IA garante ganho de 40%.";
console.log(sinaisDaFrase(fraseLocal));

A frase foi criada para demonstrar o detector e não descreve um dado real. Ela exige pelo menos fonte, definição de “ganho”, período, amostra e recálculo. O script não aprovou nem reprovou; apenas abriu quatro perguntas.

Você pode aplicar a função a um parágrafo inteiro, dividindo-o em sentenças.

const textoLocal = [
  "O material tem 12 aulas.",
  "Estude em sessões curtas.",
  "O curso foi atualizado em 2026.",
].join(" ");

const frases = textoLocal.match(/[^.!?]+[.!?]/g).map((item) => item.trim());
console.log(frases.map((frase) => ({ frase, sinais: sinaisDaFrase(frase) })));

A recomendação sobre sessões curtas não recebeu sinal automático. Ainda assim, ela pode depender do objetivo e da pessoa. Automação encontra padrões conhecidos; revisão humana pergunta se o padrão é suficiente.

Link presente não significa fonte suficiente

Uma fonte precisa passar por três portas. A URL é válida? A página é primária ou ao menos adequada para a afirmação? O conteúdo sustenta exatamente o que foi escrito? O Node consegue ajudar apenas na primeira porta e na identificação do domínio.

function inspecionarUrl(valor) {
  try {
    const url = new URL(valor);
    const protocoloSeguro = url.protocol === "https:";
    return { valida: protocoloSeguro, dominio: url.hostname, protocolo: url.protocol };
  } catch {
    return { valida: false, dominio: null, protocolo: null };
  }
}

console.log(inspecionarUrl("https://www.nist.gov/itl/ai-risk-management-framework"));
console.log(inspecionarUrl("não é uma URL"));

O primeiro endereço tem sintaxe válida e HTTPS. Isso ainda não prova qualquer frase específica. Abra a página, identifique instituição, título e data, procure o trecho relacionado e observe se há condição que a resposta omitiu.

Para evitar que um rótulo bonito esconda outro destino, compare o domínio esperado com o endereço real.

function dominioEsperado(valor, permitidos) {
  const resultado = inspecionarUrl(valor);
  return resultado.valida && permitidos.includes(resultado.dominio);
}

const oficiais = ["www.nist.gov", "nodejs.org", "ai.google.dev"];
console.log(dominioEsperado("https://nodejs.org/api/url.html", oficiais));
console.log(dominioEsperado("https://example.com/relatorio", oficiais));

Uma lista de domínios só faz sentido dentro de uma tarefa. Documentação oficial é adequada para comportamento de uma API; talvez não seja a fonte da população de uma cidade. Escolha a fonte pela afirmação, não pelo prestígio genérico.

Refaça a conta com os números de origem

Porcentagem é um lugar frequente para erro de denominador. Se 18 de 20 casos passaram, divida aprovados pelo total e preserve os dois números no registro.

function calcularTaxa(aprovados, total) {
  if (!Number.isInteger(total) || total <= 0) throw new Error("TOTAL_INVALIDO");
  if (!Number.isInteger(aprovados) || aprovados < 0 || aprovados > total) {
    throw new Error("APROVADOS_INVALIDOS");
  }
  return Number(((aprovados / total) * 100).toFixed(1));
}

console.log(calcularTaxa(18, 20));

Agora compare a afirmação recebida com a conta reproduzida. A fixture abaixo é deliberadamente inconsistente para mostrar o diagnóstico.

function conferirPercentual({ aprovados, total, informado }) {
  const calculado = calcularTaxa(aprovados, total);
  return {
    calculado,
    informado,
    confere: Math.abs(calculado - informado) < 0.05,
  };
}

console.log(conferirPercentual({ aprovados: 18, total: 20, informado: 95 }));

Mesmo quando a conta confere, pergunte de onde vieram 18 e 20. Código reproduz aritmética; não valida coleta, amostra ou interpretação. Em decisão financeira, médica, jurídica ou de segurança, encaminhe a revisão a uma pessoa qualificada.

Atualidade precisa de uma data de referência

“Hoje”, “atual” e “mais recente” envelhecem imediatamente. Registre a data da fonte e a data da conferência. Este exemplo fixa 2026-08-23 para que a saída continue reproduzível em qualquer dia de execução.

function idadeEmDias(dataFonte, dataReferencia) {
  const dia = 86_400_000;
  return Math.floor((Date.parse(dataReferencia) - Date.parse(dataFonte)) / dia);
}

const referencia = "2026-08-23";
console.log({
  fonte: "2026-08-01",
  referencia,
  idadeDias: idadeEmDias("2026-08-01", referencia),
});

Vinte e dois dias podem ser aceitáveis para uma definição estável e inadequados para preço, disponibilidade, regra ou placar. O prazo útil pertence ao domínio; o script só torna a idade explícita.

Incerteza registrada é melhor que certeza decorativa

Depois da revisão, cada afirmação deve terminar num estado: confirmada por fonte, confirmada por cálculo, precisa de especialista, desatualizada ou não verificada. Não transforme “não verificada” em “falsa”; transforme em impedimento para o uso que exigia certeza.

const itens = [
  { id: "aulas", fonteAberta: true, calculoRefeito: false, atual: true },
  { id: "taxa", fonteAberta: true, calculoRefeito: true, atual: true },
  { id: "preco", fonteAberta: false, calculoRefeito: false, atual: false },
];

function estado(item) {
  if (!item.atual) return "reconsultar";
  if (!item.fonteAberta) return "sem_evidencia";
  if (item.id === "taxa" && !item.calculoRefeito) return "refazer_calculo";
  return "pronto_para_revisao_humana";
}

console.log(itens.map((item) => ({ id: item.id, estado: estado(item) })));

“Pronto para revisão humana” também não significa publicado. Significa que as verificações mecânicas planejadas terminaram e a pessoa responsável já consegue ver fonte, conta, data e pendências. A engenharia de prompt pode pedir formato e evidência, mas não elimina essa responsabilidade.

Esta lição revisa uma resposta por vez. Uma equipe que muda prompt, modelo ou RAG precisa de muitos casos repetíveis; esse trabalho está em avaliação de aplicações de IA. O curso de engenharia de prompts organiza a prática desde o pedido até a revisão.

Missão: produza um relatório de pendências

Escreva três afirmações sobre um assunto que você conhece: uma com número, uma com data e uma recomendação. Não peça resposta a um modelo para completar a missão; o objetivo é treinar o método. Rode os sinais, associe uma fonte e refaça a conta quando houver.

const relatorio = frases.map((frase) => {
  const sinais = sinaisDaFrase(frase);
  const exigeEvidencia = sinais.numero || sinais.data || sinais.absoluta;
  return { frase, exigeEvidencia, proximoPasso: exigeEvidencia ? "conferir" : "revisar_contexto" };
});

console.log(relatorio.map(({ exigeEvidencia, proximoPasso }) => ({
  exigeEvidencia,
  proximoPasso,
})));

Você concluiu quando consegue apontar, para cada afirmação, a fonte consultada, a conta reproduzida, a data de referência e o que permaneceu incerto. O objetivo não é deixar a resposta com aparência de certeza; é impedir que uma lacuna seja escondida por uma frase bem escrita.