Existe um motivo pelo qual algumas pessoas parecem estar constantemente entregando o melhor software, escrevendo conteúdo incrível ou gerando imagens insanas…
Elas adotaram o eval loop, enquanto você…
Você tentou prompts melhores, mudou para o modelo mais caro, escreveu instruções mais longas, ativou a memória, criou arquivos de contexto do tamanho de um romance – e a porcaria (slop) continua voltando…
ela volta porque você continua consertando a camada que nunca estava quebrada
slop não é um problema de prompt, é um problema de sistema – da mesma forma que uma fábrica que produz unidades defeituosas não tem um problema de trabalhador, tem um problema de controle de qualidade. Ninguém está verificando a saída antes de ela sair do prédio.
Então esta é a construção. Ao final desta leitura, você terá um eval loop funcional rodando dentro do Hermes, o agente open-source, avaliando cada saída de acordo com seu padrão antes de ser enviada, monitorando sua saída ao vivo depois que é enviada e transformando cada falha em um novo teste, para que o piso de qualidade suba sozinho.
Nós construímos juntos, uma peça de cada vez – e o retorno é concreto: saída limpa que você pode confiar sem precisar reler à meia-noite, um número de qualidade que você pode realmente olhar, e slop que é pego na porta de saída, não pelo seu público.
Aqui está o que você vai levar:
- O verdadeiro motivo pelo qual prompts melhores, modelos maiores e memória nunca eliminam o slop de vez, e a única camada que realmente funciona.
- Os dois lugares onde o slop se esconde no seu trabalho: na sua saída de conteúdo e na sua saída de produto – e por que a correção é idêntica para ambos.
- O que é um eval loop em português claro: a camada de qualidade que pouquíssimas pessoas executam diariamente, e o motivo pelo qual ninguém nunca te disse para construir um.
- Um benchmark de qualidade que você pode montar nesta semana, tanto para conteúdo quanto para produto – exatamente o que medir e como "bom" parece como um número que você pode ler em uma tela.
- A construção exata, passo a passo, para conectar todo esse loop dentro do Hermes usando as peças que ele já te dá: skills, memória, cron, e botões de aprovação – para que o portão funcione sem você.
Se você veio aqui procurando "os 5 prompts que consertam o slop da IA", este não é esse artigo. Esses existem e não funcionam. Este é a versão que funciona.
você tentou de tudo, exceto a única coisa
Uma pequena caminhada pelo que você já fez:
Você reescreveu o prompt, três vezes, quatro vezes. Adicionou exemplos, adicionou uma persona, adicionou uma lista de "não fazer" do tamanho de uma milha.
Você fez upgrade para o modelo de fronteira, pagou 5x por token, e a saída ficou mais confiante sem ficar menos genérica.
Você ativou a memória, construiu um arquivo de contexto, alimentou com a voz da sua marca, seus trabalhos anteriores, seu guia de estilo.
E cada uma dessas jogadas te rendeu algumas boas gerações – e então o slop voltou sorrateiramente.
Cada uma delas é uma correção do lado da entrada. Você continua afiando a coisa que gera, ignorando a coisa que deveria estar capturando. Uma arma melhor disparada no escuro ainda não acerta nada.
Slop é um problema do lado da saída. Não é que o modelo não consiga produzir um bom trabalho – é que você não tem como distinguir o trabalho bom do trabalho ruim antes que ele alcance alguém importante.
Não há eval loop. Não há benchmark de qualidade. Não há placar. Então você está ajustando no escuro. Você muda um prompt e sente que ficou melhor, mas sentir não é medição – e uma sensação não captura a execução ruim escondida nas próximas 50 gerações.
Então você culpa a si mesmo, ou o seu prompt, ou a configuração do seu agente, ou a engenharia de contexto – quando a peça que falta é uma camada inteira de trabalho com IA que nunca te mostraram. E ao final deste artigo, essa camada estará rodando na sua própria máquina, dentro do Hermes.
por que prompts melhores não podem consertar isso (e por que todo mundo continua tentando mesmo assim)
Um prompt é uma hipótese. A saída é o resultado. E uma avaliação (eval) é a única coisa que fecha o ciclo entre eles.
Sem esse ciclo, você está adivinhando para sempre. Você ajusta a hipótese, avalia um resultado a olho, declara vitória – e nunca descobre que o mesmo prompt produz lixo 30% das vezes porque você só olhou para a única saída à sua frente.
O modelo é não determinístico. O mesmo prompt executado duas vezes dá duas respostas diferentes. Isso significa que mesmo um prompt perfeito produz slop em uma porcentagem das execuções – e você não tem ideia de quais execuções até que um cliente ou um usuário esteja olhando para uma.
Portanto, um prompt perfeito não é uma garantia de qualidade. É uma cara ou coroa ligeiramente melhor. E você está enviando cada lance.
O motivo pelo qual todo mundo continua recorrendo a prompts é simples: o prompt é a única alavanca que você pode realmente ver. Você pode editá-lo, e editá-lo parece controle.
A medição é invisível. Ninguém te vende um curso sobre isso. Ninguém posta um thread viral intitulado "a suíte de avaliação que 10x minha saída". Então toda a conversa fica presa na única alavanca que não consegue resolver o problema sozinha.
As pessoas cuja saída de IA é consistentemente limpa não são melhores em prompting do que você. Elas simplesmente têm uma segunda alavanca que você não tem: elas medem cada saída contra um padrão antes de enviá-la. E é a medição que faz o prompting delas parecer mágica.
os dois lugares onde o slop vive
O slop se esconde em exatamente dois lugares – e quase todo mundo está olhando apenas para um deles.
Lugar 1: sua saída de conteúdo
Os tweets, os artigos, os e-mails, as landing pages, as postagens – qualquer coisa que você gera com IA e publica sob seu nome.
Slop aqui parece um trabalho tecnicamente ok e completamente vazio. Soa como toda outra conta de IA no feed: correto por fora, vazio por dentro.
Morre em público e você não consegue articular por quê, porque cada peça individual parecia ok quando você apertou "enviar".
Lugar 2: sua saída de produto
O recurso de IA que você lançou, o agente, o chatbot, o respondedor de suporte, o pipeline de extração – a coisa que seus usuários realmente tocam.
Slop aqui parece uma resposta errada entregue com total confiança: um número alucinado, um payload JSON quebrado, um tom que não combina com a marca, uma saída que foi ótima na demonstração e silenciosamente degradou três deploys depois.
Não morre em público – escala em silêncio. Cada usuário recebe uma experiência ligeiramente pior e a maioria nunca te conta – eles simplesmente vão embora.
Essas são a mesma doença com a mesma cura.
Slop de conteúdo e slop de produto são ambos saída de IA não medida indo diretamente para um público sem nenhum portão entre eles.
A única diferença são as consequências e a visibilidade: slop de conteúdo te envergonha alto; slop de produto te sangra baixo. E o loop que construímos no Hermes avalia ambos com a mesma skill – para que você execute um sistema de qualidade sobre tudo o que gera, em vez de dois.
o que um eval loop realmente é
Um eval loop é um teste repetível que pontua sua saída de IA contra um padrão, automaticamente, toda vez – antes de ser enviada e depois de ser enviada.
É isso. É a coisa toda. E é a camada que quase ninguém que constrói com IA tem.
gerar a saída
pontuá-la contra um benchmark que você definiu
capturar as execuções que ficam abaixo da linha
consertar o que está falhando
reavaliar e deixar passar apenas a saída aprovada
Engenheiros de software têm isso há séculos – chama-se teste. Você nunca lançaria código sem testes e apenas torceria para funcionar em produção. Mas é exatamente assim que a indústria inteira está enviando saída de IA agora: direto do modelo para o usuário, na base do vibe e da oração.
O motivo pelo qual quase ninguém tem um eval loop é demográfico. As pessoas que constroem com IA hoje vieram do conteúdo, vendas, produto, founding – não da engenharia. Então "escreva testes para sua saída" nunca esteve no kit de ferramentas. Avaliações soam como infraestrutura para engenheiros "de verdade". E as pessoas que mais precisam delas assumem que não têm permissão para querer uma.
Pense nisso como teste unitário para o não determinístico. Você não está testando se o código funciona – está testando se a saída é boa. E está testando em casos suficientes para que uma execução ruim não possa se esconder.
Um eval loop roda em três lugares – e a construção a seguir coloca em todos eles:
- Antes de enviar: execute seu novo prompt ou modelo contra um conjunto salvo de casos e confirme que não piorou. Isso é teste de regressão – é como você impede que uma mudança que conserta uma coisa quebre silenciosamente outras três.
- Em tempo de execução: pontue a saída conforme ela é gerada e deixe a lógica condicional capturar as falhas antes que cheguem ao usuário. Isso é a barreira de proteção.
- Em produção: pontue uma amostra de execuções reais continuamente para que você veja a qualidade se degradando no dia em que começa, não na semana em que um cliente reclama.
Você pode montar o primeiro em uma planilha. Mas rodar todos os três continuamente sem que isso se torne um segundo emprego é a razão inteira pela qual estamos colocando isso dentro de um agente.
No momento em que a qualidade se torna um número, o slop deixa de ser uma sensação que você continua tendo e se torna um bug que você pode consertar. Você não pode depurar um vibe – você pode depurar uma pontuação que caiu de 0,82 para 0,61.
o benchmark: as três partes que você está prestes a construir
Um benchmark tem três partes – e são as mesmas três partes, quer você esteja avaliando conteúdo ou avaliando um produto:
casos de teste: entradas reais emparelhadas com o que uma boa saída parece (sua verdade fundamental)
métricas: como transformar uma saída em uma pontuação, idealmente de 0 a 1
um limite: a linha abaixo da qual nada é enviado
Construa esses três e você terá um portão de qualidade. Pule qualquer um e você terá um desejo. O resto desta seção é o que vai dentro de cada parte – depois conectamos todas as três no Hermes.
Para conteúdo: seus casos de teste são seu padrão ouro
Pegue de 20 a 50 das suas melhores peças – as bombas, as postagens que foram salvas, os artigos que você colocaria todo o seu nome por trás. Isto é o que "bom" parece. Você não está inventando um padrão – está extraindo aquele que você já alcançou nos seus melhores dias.
Para conteúdo: sua métrica é uma rubrica
Uma pontuação só é tão boa quanto a rubrica por trás dela. Então codifique o que você realmente acredita que torna o trabalho bom. Para conteúdo, eu avalio cada peça em quatro critérios:
- Explica como fazer algo específico – não um vibe, uma ação que o leitor pode realizar amanhã.
- Qualquer pessoa no público pode seguir – sem paredes de jargão, sem inside baseball.
- É estruturado, replicável, passo a passo – não apenas inspirador.
- É novo – o leitor não tinha ideia de que você poderia fazer isso.
O meta-critério sentado em cima de todos os quatro: alguém salvaria isso e voltaria para implementar depois? Se a resposta for não, é slop – não importa quão limpa a prosa pareça.
O truque é a rubrica. Uma rubrica vaga ("isso é bom e engajador?") produz uma pontuação vaga. Uma rubrica específica ("isso contém pelo menos um modelo ou playbook copiável?") produz uma pontuação que você pode confiar. O juiz herda seu gosto apenas se você realmente escrever seu gosto.
Para produto: seus casos de teste vêm dos seus logs
Pegue as entradas reais que seu recurso vê – dos seus logs, de sessões reais de usuários, não os três exemplos de happy path que você testou no dia do lançamento. Os casos que quebram você são os estranhos – e os estranhos vivem nos seus logs.
Para produto: sua métrica corresponde à tarefa
Para cada entrada, defina o que uma saída correta parece. Então combine a métrica com a tarefa: correspondência exata quando há um rótulo certo, um validador quando a estrutura precisa ser mantida, similaridade semântica mais um juiz quando a saída é aberta. A métrica só precisa retornar um número – porque um número é a única coisa em que você pode colocar um limite.
Para ambos: o limite é a linha que você mantém
0,7 é um lugar razoável para começar. Qualquer coisa abaixo de 0,7 é retrabalhada ou eliminada antes de ser enviada – sem exceções. O limite só funciona se você nunca deixar um 0,6 passar porque gostou dele. O ponto principal é tirar o ego noturno da decisão.
Esse é o benchmark. Agora vamos fazê-lo funcionar sozinho.
construindo o loop dentro do Hermes
O Hermes não vem com um botão "avaliações". Não há um dashboard chamado "qualidade" onde você clica em "ativar proteção contra slop".
O que o Hermes te dá, em vez disso, é melhor: as peças brutas de um eval loop como primitivas que você monta uma vez e depois possui.
- Skills que ele escreve para si mesmo e reutiliza.
- Memória persistente que cresce entre sessões.
- Cron integrado que entrega em qualquer plataforma.
- Botões de aprovação no Slack.
- E um hábito de autoaperfeiçoamento embutido no núcleo.
O Hermes se autodenomina "o agente que cresce com você" – e esse crescimento é exatamente o loop que estamos construindo.
Então vamos conectá-lo. Seis movimentos.
Movimento 1: levante o Hermes onde ele possa alcançar você
Instale-o e conecte-o ao Telegram. Isso importa mais do que parece – porque o portão só funciona se puder interromper você. O Hermes roda em mais de 20 canais e envia botões de aprovação nativos para o Slack e Telegram – para que o agente possa trabalhar em segundo plano e tocar no seu ombro quando uma decisão é sua.
Movimento 2: carregue seu padrão ouro na memória
O Hermes tem memória persistente que cresce entre sessões, com recuperação completa entre sessões. Então as 20 a 50 melhores peças do seu benchmark vão para lá uma vez e ficam. Esta é a parte que normalmente está espalhada por capturas de tela e rascunhos antigos. Aqui, é a memória de longo prazo do agente – consultável, a verdade fundamental contra a qual suas pontuações são medidas.
Movimento 3: transforme sua rubrica em uma *skill* de juiz
Este é o coração da coisa. Você diz ao Hermes uma vez, em português claro, para criar uma skill que pegue uma saída mais sua rubrica e retorne uma pontuação de 0 a 1 por critério com uma razão de uma linha. Isso é LLM-as-a-judge – um agente avaliando seu LLM. E um modelo com uma rubrica afiada é um crítico mais consistente do que você, porque não tem ego na peça e não tem apego àquela frase de que você está secretamente orgulhoso.
O motivo pelo qual isso vive como uma skill e não como um prompt único é que as skills do Hermes são memória processual: o agente as escreve, as mantém e as reutiliza. Você codifica seu gosto uma única vez – e ele avalia cada saída para sempre. E skills se acumulam: a Nous descobriu que agentes com mais de 20 skills auto-criadas terminam tarefas semelhantes 40% mais rápido porque param de redescobrir o processo. Seu juiz fica mais afiado quanto mais roda.
Movimento 4: transforme a suíte em uma *skill*, não em uma planilha
Seus casos de teste mais as funções de métrica se tornam uma skill que o Hermes mantém e versiona. A biblioteca de métricas é o que a tarefa precisar: correspondência exata para classificação, regex para extração, validadores JSON e chave-valor para estrutura, similaridade semântica para saída generativa.
Sua skill de juiz para as coisas abertas – o Hermes escreve o código de pontuação sozinho. Você descreve a tarefa e ele constrói a métrica. Tudo isso sentado em um só lugar que o agente possui, em vez de uma planilha que você vai perder.
Movimento 5: porte a saída com teste de regressão e um botão de aprovação
Este é o hábito de maior alavancagem em todo o sistema – e aquele que ninguém consegue manter manualmente. Então entregamos ao agente. Configure para que qualquer mudança – um novo prompt, um modelo trocado, um pipeline ajustado – dispare a suíte. O Hermes re-executa cada caso, calcula o delta da pontuação em relação à linha de base e, em vez de enviar silenciosamente, te notifica no Slack: "Pontuações foram de 0,81 para 0,74. Dois casos regrediram. Aprovar?" E só avança quando você toca no botão.
Você pode mantê-lo fixo nessa tarefa com /goal, que prende o agente a um alvo entre turnos. E para algo maior, o kanban multiagente pode decompor a execução, pontuar em paralelo e agendá-la – para que o portão seja um processo permanente, não algo que você lembra de rodar.
Movimento 6: monitore a produção em um *cron* e feche o ciclo
O Hermes tem cron integrado que entrega em qualquer plataforma. Então você agendaa uma tarefa que amostra execuções reais, as pontua com a mesma skill de juiz e te envia uma mensagem direta no momento em que a linha cai. Você pega a degradação no dia em que começa, em vez de na semana em que um cliente reclama. "'A pontuação da avaliação caiu' é um problema que você pode resolver. 'Um cliente pareceu irritado' não é."
Então a parte que faz tudo se acumular: quando você sinaliza uma saída ruim com um polegar para baixo no Slack, o Hermes a escreve de volta na skill da suíte como um novo caso de teste. Aquela execução fracassada se torna uma verificação permanente. E como o autoaperfeiçoamento é o que o Hermes é – não um recurso colocado na lateral – a suíte se endurece toda semana por conta própria. O piso sobe enquanto você dorme.
Como "bom" parece quando isso estiver rodando, concretamente: uma peça de conteúdo abaixo de 0,7 na sua rubrica nunca é enviada. Uma mudança de produto que faça qualquer métrica cair abaixo da linha de base bloqueia o deploy até que você aprove. E a linha de pontuação de produção fica estável ou sobe. No dia em que cai, é o dia em que o Hermes te chama – não a semana em que o churn aparece.
a parte que ninguém quer ouvir
O motivo pelo qual sua saída de IA é inconsistente não é que você é ruim em prompting. E não é que o modelo não é inteligente o suficiente ainda.
É que você está executando uma etapa de geração sem nenhuma etapa de qualidade. Você construiu metade de um sistema e está culpando a metade que funciona.
A correção não é um prompt melhor – é uma camada que está faltando. Defina o que "bom" parece. Transforme em um número. Pontue cada saída contra ele. Bloqueie tudo que cair abaixo da linha. E feche o ciclo para que o piso suba toda semana.
E agora essa camada não é um projeto para "um dia". São seis movimentos dentro de um agente que roda na sua própria máquina.
Faça isso – e o slop deixa de ser algo que acontece com você aleatoriamente e se torna algo que você pega na porta de saída, toda vez. Da mesma forma que uma fábrica de verdade pega um defeito antes que ele chegue a um cliente.
O prompt nunca foi o sistema.
O eval loop é o sistema. O Hermes é onde ele roda. E agora você o tem.
