Aqui está a tradução para o português (Português), seguindo rigorosamente todas as suas diretrizes.
Existe uma razão pela qual algumas pessoas parecem estar constantemente a lançar o melhor software, a escrever conteúdo incrível ou a gerar imagens insanas...
Eles adotaram o ciclo de avaliação (eval loop), enquanto você...
Você já tentou prompts melhores, mudou para o modelo mais caro, escreveu instruções mais longas, ativou a memória, construiu arquivos de contexto do tamanho de um romance, e a porcaria (slop) continua a aparecer...
ela aparece porque você continua a corrigir a camada que nunca esteve quebrada
A porcaria (slop) não é um problema de prompt, é um problema de sistemas, da mesma forma que uma fábrica que expede unidades defeituosas não tem um problema de trabalhadores, tem um problema de controlo de qualidade, ninguém está a verificar a saída antes de ela sair do edifício
então, esta é a construção. No final desta leitura, terás um ciclo de avaliação funcional a correr dentro do Hermes, o agente open-source, a pontuar cada saída de acordo com o teu padrão antes de ser enviada, a monitorizar a tua saída ao vivo depois de ser enviada, e a transformar cada falha num novo teste para que o piso de qualidade suba sozinho
Nós construímo-lo juntos, uma peça de cada vez, e a recompensa é concreta: saída limpa em que podes confiar sem teres de a reler à meia-noite, um número de qualidade que podes realmente ver, e porcaria (slop) que é apanhada à saída da porta em vez de ser pelo teu público
Aqui está o que vais obter:
- a verdadeira razão pela qual prompts melhores, modelos maiores e memória nunca eliminam a porcaria (slop) para sempre, e a única camada que realmente o faz
- os dois lugares onde a porcaria (slop) se esconde no teu trabalho: a tua saída de conteúdo e a tua saída de produto, e porque é que a correção é idêntica para ambos
- o que é um ciclo de avaliação (eval loop) em português claro, a camada de qualidade que muito poucas pessoas executam diariamente, e a razão pela qual ninguém te disse para construíres um
- um benchmark de qualidade que podes implementar esta semana, tanto para conteúdo como para produto, exatamente o que medir e o que "bom" parece como um número que podes ler num ecrã
- a construção exata, passo a passo, para ligar todo esse ciclo ao Hermes a partir das peças que ele já te dá: skills, memória, cron, e botões de aprovação, para que o portão funcione sem ti
Se vieste aqui à procura dos "5 prompts que corrigem a porcaria (slop) da IA", este não é esse artigo. Eles existem e não funcionam. Esta é a versão que funciona.
já tentaste tudo, exceto a única coisa
Uma pequena caminhada pelo que já fizeste:
Reescreveste o prompt, três vezes, quatro vezes. Adicionaste exemplos, adicionaste uma persona, adicionaste uma lista de "não faças" do tamanho de uma milha.
Fizeste upgrade para o modelo de fronteira, pagaste 5x por token, e a saída ficou mais confiante sem ficar menos genérica.
Ativaste a memória, construíste um ficheiro de contexto, alimentaste-o com a tua voz de marca, o teu trabalho passado, o teu guia de estilo.
E cada uma dessas jogadas comprou-te algumas boas gerações, depois a porcaria (slop) voltou a entrar sorrateiramente.
Cada uma delas é uma correção do lado da entrada. Continuas a afiar a coisa que gera enquanto ignoras a coisa que deveria estar a apanhar. Uma arma melhor disparada no escuro continua a não acertar em nada.
A porcaria (slop) é um problema do lado da saída. Não é que o modelo não consiga produzir bom trabalho, é que não tens forma de distinguir o bom trabalho do mau trabalho antes de ele chegar a alguém que importa.
Não há ciclo de avaliação (eval loop), não há benchmark de qualidade, não há painel de pontuação, por isso estás a sintonizar às cegas. Mudas um prompt e sentes que ficou melhor, mas sentir não é medir e uma sensação não apanha a má execução escondida nas próximas 50 gerações.
Então culpas-te a ti mesmo, ou ao teu prompt, ou à configuração do teu agente, ou à tua engenharia de contexto, quando a peça que falta é uma camada inteira de trabalho com IA que nunca te foi mostrada, e até ao final deste artigo, essa camada vai estar a correr na tua própria máquina dentro do Hermes.
porque é que prompts melhores não conseguem corrigir isto (e porque é que toda a gente continua a tentar 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, estás a adivinhar para sempre. Ajustas a hipótese, observas um resultado, declaras vitória, e nunca descobres que o mesmo prompt produz lixo 30% das vezes porque só olhaste para a única saída à tua frente.
O modelo é não-determinístico. O mesmo prompt executado duas vezes dá-te duas respostas diferentes, o que significa que mesmo um prompt \perfeito\ produz porcaria (slop) numa certa percentagem de execuções e não tens ideia de quais execuções até um cliente ou um utilizador estar a olhar para uma.
Portanto, um prompt perfeito não é uma garantia de qualidade, é um lançamento de moeda ao ar ligeiramente melhor, e estás a enviar cada lançamento.
A razão pela qual toda a gente continua a apelar aos prompts é simples: o prompt é a única alavanca que consegues realmente ver. Podes editá-lo, e editá-lo parece controlo.
A medição é invisível. Ninguém te vende um curso sobre isso, ninguém publica um tópico viral intitulado "a suíte de avaliação que 10x a minha saída". Assim, 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 a fazer prompts do que tu. Elas apenas têm uma segunda alavanca que tu não tens. Elas medem cada saída contra um padrão antes de ela ser enviada, e é a medição que faz com que os seus prompts pareçam mágica.
os dois lugares onde a porcaria (slop) vive
A porcaria (slop) esconde-se exatamente em dois lugares, e quase toda a gente só está a olhar para um deles.
lugar 1, a tua saída de conteúdo
Os tweets, os artigos, os e-mails, as landing pages, os posts, qualquer coisa que geres com IA e publiques sob o teu nome.
Porcaria (slop) aqui parece trabalho que é tecnicamente correto e completamente vazio. Soa como todas as outras contas de IA na timeline: correto por fora, vazio por dentro.
Morre em público e não consegues articular porquê, porque cada peça individual parecia ok quando clicaste em enviar.
lugar 2, a tua saída de produto
A funcionalidade de IA que lançaste, o agente, o chatbot, o respondedor de suporte, o pipeline de extração, a coisa que os teus utilizadores realmente tocam.
Porcaria (slop) aqui parece uma resposta errada entregue com confiança total, um número alucinado, um payload JSON quebrado, um tom que não é o da marca, uma saída que foi ótima na demo e se degradou silenciosamente três deploys depois.
Não morre em público, escala em silêncio. Cada utilizador tem uma experiência ligeiramente pior e a maioria deles nunca te diz, eles simplesmente vão embora.
Estas são a mesma doença com a mesma cura.
A porcaria (slop) de conteúdo e a porcaria (slop) de produto são ambas saída de IA não medida a ir diretamente para um público sem nenhum portão no meio.
A única diferença são os riscos e a visibilidade. A porcaria (slop) de conteúdo envergonha-te alto e bom som, a porcaria (slop) de produto sangra-te silenciosamente. E o ciclo que construímos no Hermes avalia ambas com a mesma skill, para que executes um sistema de qualidade em tudo o que geras, em vez de dois.
o que é realmente um ciclo de avaliação (eval loop)
Um ciclo de avaliação é um teste repetível que pontua a tua saída de IA contra um padrão, automaticamente, sempre, antes de ser enviada e depois de ser enviada.
É só isso, é a coisa toda. E é a camada que quase ninguém que constrói com IA tem.
gera a saída
pontua-a contra um benchmark que definiste
apanha as execuções que ficam abaixo da linha
corrige o que está a falhar
reavalia, e deixa passar apenas a saída aprovada
Os engenheiros de software sempre tiveram isto, chama-se teste. Nunca enviarias código sem testes e apenas esperarias que funcionasse em produção, mas é exatamente assim que a indústria inteira envia saída de IA agora, diretamente do modelo para o utilizador baseado numa vibe e numa oração.
A razão pela qual quase ninguém tem um ciclo de avaliação é demográfica. As pessoas que constroem com IA hoje vieram do conteúdo, vendas, produto, fundação, não da engenharia. Portanto, "escreve testes para a tua saída" nunca esteve no kit de ferramentas. As avaliações (evals) são lidas como infraestrutura para engenheiros "a sério", e as pessoas que mais precisam delas assumem que não têm permissão para querer uma.
Pensa nisto como testes unitários para o não-determinístico. Não estás a testar se o código corre, estás a testar se a \saída é boa\, e estás a testá-la em casos suficientes para que uma má execução não se possa esconder.
Um ciclo de avaliação corre em três lugares, e a construção a seguir coloca-o nos três:
- Antes de enviares: Executa o teu novo prompt ou modelo contra um conjunto guardado de casos e confirma que não piorou. Isto é teste de regressão. É como impedes que uma mudança que corrige uma coisa quebre silenciosamente três outras.
- Em tempo de execução: Pontua a saída à medida que é gerada e deixa a lógica condicional apanhar as falhas antes de chegarem ao utilizador. Isto é a barreira de proteção (guardrail).
- Em produção: Pontua uma amostra de execuções reais continuamente para que possas ver a qualidade a degradar-se no dia em que começa, não na semana em que um cliente reclama.
Podes implementar o primeiro numa folha de cálculo, mas executar todos os três continuamente sem que se torne um segundo trabalho é a razão principal pela qual estamos a colocar isto dentro de um agente.
No momento em que a qualidade se torna um número, a porcaria (slop) deixa de ser um sentimento que continuas a ter e torna-se um bug que podes corrigir. Não podes depurar uma vibe, podes depurar uma pontuação que caiu de 0.82 para 0.61.
o benchmark, as três partes que estás prestes a construir
Um benchmark tem três partes, e são as mesmas três partes quer estejas a avaliar conteúdo ou a avaliar um produto:
casos de teste, inputs reais emparelhados com o aspeto que uma boa saída tem (a tua verdade fundamental / ground truth)
métricas, como transformas uma saída numa pontuação, idealmente de 0 a 1
um limiar, a linha abaixo da qual nada é enviado
Constrói estas três e tens um portão de qualidade. Salta qualquer uma e tens um desejo. O resto desta secção é o que vai dentro de cada parte, depois ligamos todas as três dentro do Hermes.
Para conteúdo, os teus casos de teste são o teu padrão ouro
Pega em 20 a 50 das tuas melhores peças. Os bangers, os posts que foram marcados, os artigos pelos quais colocarias o teu nome inteiro. Isto é o que "bom" parece. Não estás a inventar um padrão, estás a extrair aquele que já atingiste nos teus melhores dias.
Para conteúdo, a tua métrica é uma rubrica
Uma pontuação é tão boa quanto a rubrica por detrás dela. Portanto, codifica o que realmente acreditas que torna o trabalho bom. Para conteúdo, eu avalio cada peça com base em quatro critérios:
- Explica como fazer algo específico, não uma vibe, uma ação que o leitor possa tomar amanhã.
- Qualquer pessoa na audiência consegue segui-lo, sem muros de jargão, sem inside baseball.
- É estruturado, replicável, passo a passo, não apenas inspirador.
- É novo, o leitor não fazia ideia que podias fazer isto.
O meta-critério que se senta no topo dos quatro: Alguém marcaria isto e voltaria para implementar mais tarde? Se a resposta for não, é porcaria (slop), não importa o quão limpa a prosa leia.
O truque é a rubrica. Uma rubrica vaga ("isto é bom e envolvente") produz uma pontuação vaga. Uma rubrica específica ("isto contém pelo menos um modelo ou playbook copiável e colável") produz uma pontuação em que podes confiar. O juiz herda o teu gosto apenas se realmente escreveres o teu gosto.
Para produto, os teus casos de teste vêm dos teus logs
Pega nos inputs reais que a tua funcionalidade vê. Dos teus logs, de sessões reais de utilizadores. Não os três exemplos de caminho feliz que testaste no dia do lançamento. Os casos que te partem são os estranhos, e os estranhos vivem nos teus logs.
Para produto, a tua métrica corresponde à tarefa
Para cada input, define o aspeto de uma saída correta. Depois, combina a métrica com a tarefa. Correspondência exata quando há um rótulo correto. Um validador quando a estrutura tem de se manter. Similaridade semântica mais um juiz quando a saída é aberta. A métrica apenas tem de retornar um número porque um número é a única coisa em que podes colocar um limiar.
Para ambos, o limiar é a linha que defendes
0.7 é um lugar razoável para começar. Qualquer coisa abaixo de 0.7 é retrabalhada ou morta antes de ser enviada. Sem exceções. O limiar só funciona se nunca deixares passar um 0.6 porque gostaste dele. O objetivo é tirar o ego da decisão a altas horas da noite.
Esse é o benchmark. Agora vamos fazê-lo funcionar sozinho.
construir o ciclo dentro do Hermes
O Hermes não tem um botão de avaliações (evals). Não há um painel chamado qualidade onde cliques em "ativar proteção contra porcaria (slop)".
O que o Hermes te dá é melhor: as peças brutas de um ciclo de avaliação como primitivas que montas uma vez e depois possuis.
Skills que ele escreve para si mesmo e reutiliza. Memória persistente que cresce entre sessões. Cron incorporado que entrega em qualquer plataforma. Botões de aprovação no Slack. E um hábito de auto-aperfeiçoamento incorporado no núcleo.
O Hermes chama a si mesmo "o agente que cresce contigo" e esse crescimento é exatamente o ciclo que estamos a construir.
Então, vamos ligá-lo. Seis movimentos.
Movimento 1: Colocar o Hermes num lugar onde ele te possa alcançar
Instala-o e conecta-o ao Telegram. Isto importa mais do que parece, porque o portão só funciona se te puder interromper. O Hermes corre em mais de 20 canais e envia botões de aprovação nativos para o Slack e Telegram, para que o agente possa fazer trabalho em segundo plano e tocar-te no ombro quando uma decisão é tua.
Movimento 2: Carregar o teu padrão ouro na memória
O Hermes tem memória persistente que cresce entre sessões com recuperação total entre sessões. Portanto, as 20 a 50 melhores peças do teu benchmark vão para lá uma vez e ficam. Esta é a parte que normalmente está espalhada por capturas de ecrã e rascunhos antigos. Aqui, é a memória de longo prazo do agente, consultável. A verdade fundamental (ground truth) contra a qual as tuas pontuações serão medidas.
Movimento 3: Transformar a tua rubrica numa skill de juiz
Este é o coração da coisa. Dizes ao Hermes uma vez, em português claro, para criar uma skill que pegue numa saída mais a tua rubrica e retorne uma pontuação de 0 a 1 por critério com uma razão de uma linha. Isto é IA-como-juiz (LLM-as-a-judge), um agente a avaliar o teu LLM. E um modelo com uma rubrica afiada é um crítico mais consistente do que tu porque não tem ego na peça e nenhum apego à única frase de que estás secretamente orgulhoso.
A razão pela qual isto vive como uma skill e não como um prompt único é que as skills do Hermes são memória processual. O agente escreve-as, mantém-nas e reutiliza-as. Codificas o teu gosto uma única vez e ele avalia cada saída para sempre. E as skills acumulam-se. 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. O teu juiz fica mais afiado quanto mais corre.
Movimento 4: Tornar a suíte uma skill, não uma folha de cálculo
Os teus casos de teste mais as funções métricas tornam-se uma skill que o Hermes deté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 de chave-valor para estrutura, similaridade semântica para saída generativa.
A tua skill de juiz para as coisas abertas: o Hermes escreve o código de pontuação ele próprio. Descreves a tarefa e ele constrói a métrica. Tudo a residir num só lugar que o agente possui, em vez de uma folha que vais perder.
Movimento 5: Bloquear o envio com testes 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 mantém manualmente. Por isso, entregamo-lo ao agente. Liga-o para que qualquer mudança, um novo prompt, um modelo trocado, um pipeline ajustado, dispare a suíte. O Hermes reexecuta cada caso, calcula o delta da pontuação em relação ao valor de referência (baseline) e, em vez de enviar silenciosamente, envia-te um ping no Slack: "Pontuações foram de 0.81 para 0.74, dois casos regrediram, aprovas?". E só avança quando carregas no botão.
Podes mantê-lo bloqueado nessa tarefa com /goal, que prende o agente a um alvo ao longo de várias voltas. E para qualquer coisa maior, o seu kanban multi-agente pode decompor a execução, pontuar em paralelo e agendá-la. Assim, o portão é um processo permanente, não uma coisa de que te lembras de executar.
Movimento 6: Monitorizar a produção com um cron e fechar o ciclo
O Hermes tem cron incorporado que entrega em qualquer plataforma. Portanto, agendas um trabalho que amostra execuções reais, as pontua com a mesma skill de juiz, e te envia uma DM no momento em que a linha desce. Apanhas a degradação no dia em que começa, em vez de na semana em que um cliente reclama. "A pontuação de avaliação caiu" é um problema sobre o qual podes agir. "Um cliente pareceu irritado" não é.
Depois, a parte que faz a coisa toda acumular-se. Quando assinalas uma má saída com um polegar para baixo no Slack, o Hermes escreve-a de volta na skill da suíte como um novo caso de teste. Essa execução falhada torna-se uma verificação permanente. E porque o auto-aperfeiçoamento é o que o Hermes é, não uma funcionalidade aparafusada ao lado, a suíte endurece todas as semanas sozinha. O piso sobe enquanto dormes.
Qual é o aspeto de "bom" quando isto estiver a funcionar, de forma concreta? Uma peça de conteúdo abaixo de 0.7 na tua rubrica nunca é enviada. Uma mudança de produto que faça cair qualquer métrica abaixo do valor de referência bloqueia o deploy até aprovares. E a linha da pontuação de produção mantém-se estável ou sobe. No dia em que desce, é o dia em que o Hermes te envia um ping, não a semana em que a rotatividade (churn) aparece.
a parte que ninguém quer ouvir
A razão pela qual a tua saída de IA é inconsistente não é que sejas mau a fazer prompts. E não é que o modelo ainda não seja suficientemente inteligente.
É que estás a executar um passo de geração sem nenhum passo de qualidade. Construíste metade de um sistema e tens estado a culpar a metade que funciona.
A correção não é um prompt melhor. É uma camada em falta. Define o aspeto de "bom", transforma-o num número, pontua cada saída contra ele, bloqueia tudo o que fica abaixo da linha, e fecha o ciclo para que o piso suba todas as semanas. E agora essa camada não é um projeto para "um dia destes". São seis movimentos dentro de um agente que corre na tua própria máquina.
Faz isso e a porcaria (slop) deixa de ser uma coisa que te acontece aleatoriamente e torna-se uma coisa que apanhas à saída da porta, sempre. Da mesma forma que uma fábrica a sério apanha um defeito antes de ele chegar a um cliente.
O prompt nunca foi o sistema.
O ciclo de avaliação (eval loop) é o sistema. O Hermes é onde ele corre. E agora tu tens-no.
