Vou te mostrar passo a passo como obter consistentemente os melhores resultados com Claude Code, Codex, OpenCode ou qualquer outra ferramenta que você estiver usando...
porque uma ferramenta é apenas o aplicativo onde você digita suas instruções para o agente, o cockpit onde você se senta
o instinto é buscar um modelo melhor para colocar dentro dela (USANDO FABLE 5 LOL)
a verdadeira vantagem que você pode obter está em outro lugar, no fato de você ter parado em um único modelo
e o momento torna esse erro mais caro do que costumava ser... porque o melhor modelo individual se tornou um alvo móvel no qual você não pode contar:
- Fable 5 está voltando por cerca de uma semana e depois ficará caro demais para pagar
- Mythos 5 está restrito a uma pequena lista de empresas aprovadas pelo governo
- GPT-5.6 Sol foi disponibilizado para cerca de 20 empresas aprovadas e mais ninguém
então apostar toda a sua operação no modelo que é o "melhor" neste mês continua perdendo força no momento em que ele é restrito
então a jogada é uma fusão de LLMs de ponta, um punhado de modelos trabalhando juntos em vez de um único modelo carregando tudo
é isso que separa os resultados medianos dos melhores, e é a primeira coisa que eu configuro em todo projeto agora
se você quer aprender como extrair o máximo dessas ferramentas e ganhar dinheiro de verdade com elas, é para isso que a comunidade de operações de IA em tempo real foi criada: weeklyaiops.com
a ida e volta lenta e miserável
veja como um projeto normal acontece, o gargalo está bem no meio dele:
você abre uma ferramenta e entrega a tarefa a ela
então você pega o plano dela, cola em um segundo modelo e pergunta "isso está certo?"
o segundo encontra as falhas, então você leva essas anotações de volta para o primeiro
você passa a tarde como um mensageiro, transportando contexto entre dois modelos que não podem conversar entre si
vamos ser honestos, essa ida e volta é um saco...
eu conheço bem esse ciclo, você faz o Claude verificar o plano do Codex, depois leva as falhas de volta para o outro lado, e o dia desaparece transportando anotações entre dois modelos
por que uma fusão de IAs supera seu modelo favorito
há uma razão pela qual o segundo modelo continua pegando coisas que o primeiro perdeu...
o modelo que revisa o trabalho compartilha os pontos cegos do modelo que o criou, porque eles falham nos mesmos lugares
então pedir para um modelo se verificar resulta em um confiante "parece bom para mim" exatamente no bug que ele mesmo teria escrito
um conselho corrige isso estruturalmente, não com um prompt melhor - porque modelos diferentes cobrem os pontos fracos uns dos outros
e a prova disso é respaldada por artigos reais:
uma equipe de pesquisa na Sakana construiu um coordenador pequeno o suficiente para rodar em um laptop, um modelo que nunca responde sua pergunta
ele lê a pergunta
decide qual modelo grande deve lidar com cada parte
e distribui o trabalho
eles o apontaram para GPT-5, Gemini e Claude, e ele venceu todos os três sozinho...
então eles tentaram colocar um modelo de primeira linha para fazer a coordenação, e ele foi pior lol
então o maestro não precisa ser o modelo mais forte que você tem, mas precisa ler o problema e roteá-lo para quem é melhor naquela parte
os três papéis, e aquele que é ignorado
o coordenador dá a cada modelo um trabalho de cada vez:
pensador: dividir a tarefa, construir o plano, encontrar falhas nele
trabalhador: fazer o trabalho, o rascunho, o código, os números, seja qual for a entrega
verificador: julgar o resultado e dizer "pode ir" ou "corrija isso"
o verificador é ignorado, e é o que mais importa
o trabalho não está terminado quando um modelo produz algo... está terminado quando um verificador o aprova
essa única regra, uma condição clara de "pronto", é toda a diferença entre um loop que termina e um que gira em círculos para sempre
passe a ida e volta para um conselho
agora, adicionar um coordenador pode parecer mais uma camada para gerenciar
mas na verdade é o oposto, a camada que você tira é aquela que era você
então a jogada é simples, você delega a própria coordenação: você para de ser o mensageiro e deixa um coordenador executar o loop de pensador, trabalhador e verificador para você
eu uso o Fugu para isso agora (sakana.ai/fugu), e para ser claro, isso não é patrocinado, eu simplesmente amo ele
é a versão comercializada daquela pesquisa, você aponta sua ferramenta para ele da mesma forma que apontaria para qualquer outro modelo, e ele executa o conselho por trás de uma única solicitação
vou ser honesto sobre o que ele é, porque isso é importante
ele tem alguns dias de vida, leva seu tempo porque está genuinamente executando um conselho em vez de fingir um, e é mais forte como verificador, aquele que detona o trabalho antes de você enviar
$20 te dá acesso, com um segundo mês grátis se você começar antes do final de julho
eu não confio cegamente nele, confio no padrão de conselho, e esta é a maneira mais fácil que encontrei de executar esse padrão sem ficar de babá
agora vamos ao passo a passo do fluxo de trabalho para obter consistentemente os melhores resultados com QUALQUER ferramenta de agente:
execute o conselho no início e no final
eu trago o conselho em dois momentos em todo projeto, bem no início e na entrega
imagine um trabalho real, lançar uma newsletter, construir uma lista de leads, enviar uma landing page
1. entreviste primeiro - antes de qualquer trabalho acontecer, faça seu agente te entrevistar em profundidade (o grill-me do matt é uma skill que faz o agente te questionar sobre tudo), a profundidade dessa entrevista define o teto para tudo que vem depois
2. convoque o conselho - para construir o plano, o coordenador lida com a parte de múltiplos modelos para que você não fique mais colando entre ferramentas
3. defina os loops - defina a meta e a condição de parada antecipadamente para que possa rodar sem você assistir cada passo
4. delegue por papel - envie a tarefa certa para o lugar certo e apoie-se em subagentes (um subagente é apenas um agente auxiliar para quem o principal passa o trabalho)
5. detone na entrega - quando o trabalho parecer pronto, envie-o de volta pelo conselho para despedaçá-lo antes de sair
mesmo loop, duas pontas, planejamento no início e detonação no final - esse é o motor inteiro, e isso mudou profundamente a rapidez com que posso enviar algo em que confio
o conselho é o motor, a configuração o mantém afiado
um motor é tão bom quanto a máquina ao seu redor...
então aqui estão seis movimentos que mantêm cada agente no conselho produzindo seu melhor, nenhum deles complicado
1. construa suas próprias skills, não baixe uma biblioteca
uma skill é um conjunto salvo de instruções que seu agente pode reutilizar, como uma receita que ele segue (nada mais que um arquivo markdown com exemplos...)
a tentação é pegar uma grande biblioteca de skills que outra pessoa publicou e simplesmente executá-la
eu pularia essa, cerca de um terço das públicas carregam uma falha de segurança... se não pior lol
e mesmo as limpas são o contexto de outra pessoa, não o seu, uma skill só ajuda depois que você pessoalmente encontrou o muro que ela resolve
antes disso, é apenas ruído ocupando a memória do agente
então este é meu conselho: construa as poucas que você realmente precisa, extraídas de suas próprias execuções fracassadas, é aí que está a verdadeira vantagem
2. prefira CLIs pequenos, não servidores MCP
duas palavras rápidas primeiro, um MCP é uma forma de acoplar ferramentas extras ao seu agente, e um CLI é um comando pequeno que você executa na janela de texto
o reflexo é acoplar um MCP para tudo, e cada um carrega sua folha de instruções completa na memória do agente antes mesmo de você fazer sua primeira pergunta
essas descrições de ferramenta podem consumir mais de 100.000 palavras de memória antecipadamente, sufocando o trabalho real
então, para tarefas do dia a dia, opte por um CLI pequeno, é mais leve, o agente já sabe como executar um comando, e sua saída cai em um arquivo em vez de entupir a memória
uma ferramenta chamada printing-press (printingpress.dev) escreverá um desses para qualquer serviço a partir de um único prompt... abuse dela
guarde os MCPs para os trabalhos que realmente precisam deles, logins compartilhados, muitos usuários, uma conexão ao vivo que precisa ficar aberta
a regra é CLI primeiro, não apenas CLI
3. mantenha o arquivo de instruções leve
seu agente lê um arquivo de instruções antes de cada tarefa, geralmente AGENTS.md ou CLAUDE.md
a vontade é entupi-lo com tudo que você puder pensar, e o agente acaba seguindo menos, não mais
um modelo segue confiavelmente cerca de 150 a 200 instruções, depois começa a deixá-las cair
mantenha o seu abaixo de 100 linhas - funciona melhor assim
4. limpe o contexto, mantenha a memória em arquivos
a janela de contexto é a memória de curto prazo do seu agente, e ela enche e fica mais burra conforme avança
Claude Opus 4.8 é um ótimo exemplo... este é um modelo excepcional, mas assim que você atinge 300-400k tokens, você deve 100% limpar o contexto - NÃO USE COMPACTAÇÃO
então limpe-a com frequência, e mantenha a memória que importa em arquivos
um learnings.md que o agente lê no início de uma sessão e atualiza no final, toda vez, mesmo quando acha que nada mudou
faça-o atualizar essas anotações após cada commit, um commit sendo um checkpoint salvo do trabalho
as regras duráveis vivem no arquivo de instruções, as coisas que ele aprende ao longo do caminho vivem em learnings, e se você está editando seu arquivo de regras após cada execução, colocou as coisas erradas nele
eu construí para mim uma skill chamada /before-clear, ela simplesmente cria um checkpoint no projeto, um arquivo temporário que o agente lê primeiro... ele tem um todo muito simples, um breve resumo do que aconteceu na última sessão e qual é a próxima tarefa mais urgente
eu raramente perco qualquer contexto importante de uma sessão para outra
5. escreva poucas regras, cada uma simples
uma lista curta de regras claras é MUITO melhor do que uma longa pilha de regras engenhosas
quando um arquivo de regras fica longo, as regras começam a competir entre si, e o agente tem que adivinhar qual vence
escreva cada regra como você diria a um novo contratado, uma linha, um significado, sem espaço para interpretação
quando a regra é clara, o agente a segue, quando é vaga, o agente improvisa, e improvisar é exatamente onde seus resultados se desviam
6. delegue o trabalho pesado para subagentes
empurre o trabalho complicado e caro para subagentes, especialmente qualquer coisa que toque o navegador
dirigir o navegador a partir do agente principal pode queimar MUITO contexto só com capturas de tela
passe esse mesmo trabalho para um subagente e ele volta com "pronto, aqui está o resumo" em uma linha ou duas
o agente principal continua sendo o maestro, os ajudantes fazem o alcance, e sua memória principal permanece limpa
é a ideia do conselho novamente, um nível abaixo, você coordena o trabalho em vez de fazer tudo sozinho
todo o sistema operacional, em um bloco
o melhor modelo continua sendo restrito, então um único modelo não pode ser sua base
passe a coordenação para um conselho: pensador planeja, trabalhador constrói, verificador aprova
o verificador é a condição de parada, o trabalho está pronto quando ele diz, não antes
execute o conselho duas vezes, no início para planejar e na entrega para detonar
eu uso o Fugu para executá-lo, $20 para testar, não patrocinado, honesto sobre ser recente
então mantenha cada agente afiado:
construa suas próprias skills, não baixe uma biblioteca
CLI primeiro, MCPs apenas quando você realmente precisar deles
arquivo de instruções com menos de 100 linhas
limpe o contexto com frequência, mantenha a memória em arquivos
poucas regras, cada uma simples
delegue o trabalho pesado para subagentes
todo o resto além disso é pura otimização que você provavelmente nem vai notar a menos que seja um engenheiro de software
é assim que você constrói para si mesmo um sistema operacional que performa, com ou sem Fable 5...
de qualquer forma, estou construindo a melhor comunidade de IA do mundo, que tal se juntar a mim?
