# Benchmark de modelos de IA para programação no seu próprio repositório

> Para fazer um benchmark de modelos de IA para programação, rode as mesmas tarefas reais do seu repositório com vários agentes ou modelos, cada um num workspace isolado, e pontue cada resultado com a mesma rubrica: testes passando, tamanho do diff, esforço de revisão, retrabalho e tempo. Ranking público mede a tarefa dos outros; um benchmark pequeno no seu código mostra qual configuração usar em cada tipo de trabalho.

- Canonical: https://runtallos.com/pt/aprenda/benchmark-de-modelos-no-seu-repositorio
- English: https://runtallos.com/learn/benchmark-ai-models-on-your-repo.md
- Autor: [Roberto Rocha](https://www.instagram.com/robertorochamkt/)
- Atualizado em: 2026-09-30
- Section: Aprenda

## Em resumo

- 3 a 5 tarefas reais do seu próprio backlog
- Mesma tarefa, mesmo prompt, worktrees isolados
- Pontue com rubrica fixa, não com impressão
- Decida por tipo de tarefa, não por um vencedor geral
- Template de squad no Tallos: 3 tentativas, escolhe a melhor

## Por que benchmark público não diz qual modelo é melhor para o seu código?

Benchmarks públicos de programação medem como um modelo se sai num conjunto fixo de tarefas dos outros, num setup dos outros. O seu trabalho é diferente em quase tudo o que decide se um diff presta.

- **Outro código.** Suas linguagens, frameworks, bibliotecas internas e convenções não estão no conjunto de teste.
- **Outro harness.** Você roda um agente de CLI com ferramentas, prompts e gestão de contexto próprios, não o modelo puro. O mesmo modelo pode se comportar diferente dentro de dois agentes.
- **Outra definição de pronto.** Quem define a régua são seus testes, seu linter e seus revisores, não o critério do benchmark.
- **Alvo em movimento.** Modelos e CLIs de agentes mudam o tempo todo; o ranking do trimestre passado pode não valer para as versões que você roda hoje.
- **Diferenças difíceis de ler.** Tarefas públicas populares podem vazar para os dados de treino, e as notas do topo costumam ficar coladas.

Ranking serve para montar uma lista curta. Quem bate o martelo é um teste no seu código, com os agentes que você realmente usa (veja [como Claude Code, Codex e Gemini CLI se comparam](https://runtallos.com/pt/comparar/claude-code-vs-codex-vs-gemini-cli)).

## O que é um benchmark no seu próprio repositório?

Um **benchmark de repositório** é um teste pequeno e repetível que dá as mesmas tarefas reais do seu código para vários agentes ou modelos de IA, roda cada tentativa isolada e pontua os resultados com uma rubrica só. Ele responde uma pergunta mais estreita que um ranking, "qual configuração eu uso para este tipo de tarefa, neste repo?", que é a pergunta que você tem de verdade.

Cada concorrente é uma **entrada**: um agente, um modelo e um nível de esforço. De duas a quatro entradas bastam.

## Como escolher as tarefas de um benchmark de programação?

Escolha de três a cinco tarefas parecidas com o seu trabalho real, cada uma com uma definição de pronto que dá para conferir.

- **Correção de bug com reprodução:** um teste falhando ou passos claros.
- **Uma feature pequena** que mexe em dois ou três arquivos.
- **Um refactor** de código que já tem teste cobrindo.
- **Testes** para um módulo com pouca cobertura.
- **O canto mais esquisito do projeto:** o módulo legado, o framework interno, o script de build. É onde o treino genérico ajuda menos.
- **Fora:** tarefas que precisam de segredos de produção ou serviços ao vivo, ou grandes demais para duas tentativas serem comparáveis.

> **Refaça trabalho que você já entregou** — Refaça tickets que seu time já resolveu: crie uma branch no commit logo antes da correção, dê o ticket original para todas as tentativas e compare cada diff com o que foi mergeado. Você já sabe como é a resposta boa.

## Como rodar a mesma tarefa com vários agentes ao mesmo tempo?

Dê a cada entrada o mesmo prompt, o mesmo commit de partida e um workspace isolado, para uma tentativa não ver nem sobrescrever a outra. No Tallos, dá para fazer na mão ou com uma squad.

|  | Workspaces na mão | Squad "3 tentativas, escolhe a melhor" |
| --- | --- | --- |
| Montagem | Um workspace por entrada, cada um com sua git worktree e branch; abra um agente diferente em cada e cole o mesmo prompt | Escolha o template; defina agente, modelo e esforço por membro |
| Isolamento | Uma worktree por workspace | O líder inicia cada tentativa num worktree filho novo |
| Quem compara | Você | O líder compara correção, testes e qualidade do diff e recomenda uma; quem decide é você |


O template já vem com um membro, "Resolve o objetivo inteiro de forma independente", com **Quantos** = 3. Para comparar agentes ou modelos diferentes, use três membros com essa função, cada um com **Quantos** = 1 e seu próprio agente, modelo e esforço. Veja o [playbook melhor de três](https://runtallos.com/pt/squads/melhor-de-tres) para uma execução completa, e como os [workspaces paralelos](https://runtallos.com/pt/recursos/workspaces-paralelos) usam [git worktrees](https://runtallos.com/pt/aprenda/git-worktrees-para-agentes-de-ia) para manter as tentativas separadas.

> **Condições iguais para todo mundo** — Mesmo commit base, prompt, modo de permissão e ferramentas. Se um agente perguntar algo, dê a mesma resposta para todas as tentativas. Não compare tempos de tentativas que rodaram suítes de teste pesadas lado a lado: elas dividem a sua máquina.

> Faça sua primeira comparação: uma tarefa, três agentes, três worktrees isolados. → https://runtallos.com/signup

## Como avaliar agentes de IA de programação? Uma rubrica que funciona

Pontue todas as tentativas com os mesmos critérios e anote as notas antes de olhar qual agente gerou qual diff. Se alguém do time puder renomear as branches para A, B e C, revise às cegas.

| Critério | O que conferir | Como pontuar |
| --- | --- | --- |
| Testes passando | Suíte atual, testes que a tarefa pede, lint, checagem de tipos | Passou ou falhou; anote o que falhou |
| Tamanho e escopo do diff | Arquivos e linhas alterados, mudanças fora da tarefa, dependências novas | Menor ganha se resolver; marque o que fugir do escopo |
| Esforço de revisão | Quanto tempo você levou para entender e confiar no diff | De 1 a 5: 5 = merge como está, 1 = reescrever você mesmo |
| Retrabalho | Prompts extras ou comentários de linha até ficar pronto | Conte; a meta é zero |
| Tempo | Tempo de relógio do prompt até um resultado revisável | Minutos; pese por último |
| Uso | Quanto a tentativa gastou da sua assinatura ou chave de API | Anote quando o agente informar |

_Não existe peso universal; defina os seus antes de rodar. Em correção de bug, testes e esforço de revisão costumam pesar mais._

Leia cada tentativa na [revisão de diff](https://runtallos.com/pt/recursos/revisao-de-diff); cada comentário de linha que você devolve ao agente conta como retrabalho. Numa squad, edite as instruções do líder para o relatório final trazer esses campos por tentativa, e trate o selo **Recomendado** como um dado a mais, não como o veredito.

## Como fazer um benchmark no meu repositório, passo a passo?

1. **Monte uma lista de duas a quatro entradas** — Escolha agente, modelo e esforço de cada uma e [conecte os agentes](https://runtallos.com/pt/aprenda/conectar-seus-agentes) no Tallos.
2. **Escolha de três a cinco tarefas** — Do backlog ou de tickets já resolvidos, cada uma com a definição de pronto escrita.
3. **Congele o setup** — Mesmo commit base, prompt e modo de permissão. Escreva a rubrica e os pesos antes de rodar qualquer coisa.
4. **Rode as tentativas isoladas** — Um workspace por entrada, ou uma squad "3 tentativas, escolhe a melhor" com um membro por entrada.
5. **Revise e pontue** — Abra as alterações de cada tentativa, rode as checagens e preencha a rubrica. Às cegas, se der.
6. **Repita os casos apertados** — Agente não gera o mesmo diff toda vez. Quando duas entradas ficarem próximas, rode a tarefa de novo.
7. **Decida por tipo de tarefa** — Anote qual entrada vai para bug, feature, refactor e teste, e quando você vai rodar de novo.

## Como transformar o resultado do benchmark numa decisão?

Decida por tipo de tarefa, não no geral. É normal uma entrada ganhar em correção de bug e outra em testes.

- **Confie em diferença consistente, não em vitória isolada.** Ganhar o mesmo tipo de tarefa duas vezes é sinal; uma tentativa brilhante, não.
- **Dê peso ao esforço de revisão.** Um diff que passa nos testes mas leva uma hora para ganhar sua confiança custa mais que um maior que você lê em cinco minutos.
- **Coloque o uso na conta.** Deu empate, fique com a entrada que gasta menos. Veja [quanto custa rodar agentes em paralelo](https://runtallos.com/pt/aprenda/quanto-custa-rodar-agentes-em-paralelo).
- **Transforme em padrão.** Guarde a vencedora como squad salva, ou numa tabelinha no repo: tipo de tarefa, agente, modelo, esforço.
- **Rode de novo quando algo mudar:** modelo novo, versão nova do CLI, refactor grande.

> **Por que esta página não tem notas** — A gente não publica ranking de agentes nem de modelos. O resultado depende do seu código, dos seus prompts e das versões que você roda, e muda a cada atualização dos fornecedores. O que se transfere é o método.

> Faça o benchmark dos agentes que você já paga, no código que você realmente entrega. → https://runtallos.com/signup

## Perguntas frequentes

### Qual o melhor modelo de IA para programação?

Nenhuma resposta vale para todo código. Rode de dois a quatro agentes ou modelos nas mesmas tarefas reais do seu repositório e pontue; a melhor escolha costuma mudar conforme o tipo de tarefa.

### Como fazer benchmark de agentes de IA no meu próprio código?

Escolha de três a cinco tarefas representativas, dê a cada agente o mesmo prompt e o mesmo commit de partida num workspace isolado e pontue as tentativas em testes, tamanho do diff, esforço de revisão, retrabalho e tempo.

### Dá para confiar em benchmark público de IA para programação?

Serve para montar uma lista curta, mas mede tarefas fixas num setup só. Seu código, seus testes e o CLI do agente são outros, então a posição no ranking raramente decide o que usar no seu repositório.

### Quantas tarefas preciso para comparar Claude Code, Codex e Gemini CLI?

De três a cinco tarefas representativas costumam mostrar diferenças claras. Rode de novo os casos apertados, porque agente não gera a mesma saída toda vez.

### Dá para comparar modelos diferentes dentro do mesmo agente?

Dá. Numa squad do Tallos cada membro tem seu agente, modelo e esforço, então o mesmo agente pode rodar a mesma tarefa com três modelos ou níveis de esforço.

### Quanto custa fazer benchmark de agentes de IA?

Cada tentativa usa a sua assinatura ou chave de API, então três entradas em quatro tarefas são doze execuções de uso. Confira os preços atuais na página oficial de cada fornecedor.

### O Tallos publica ranking de agentes de IA?

Não. O Tallos te dá workspaces isolados, uma squad de melhor de N e a revisão de diff para você mesmo comparar, no seu código.

## Fontes

1. [git-worktree documentation](https://git-scm.com/docs/git-worktree) — Git

---

**Rode seus agentes em paralelo com o Tallos** — Claude Code, Codex, Gemini e mais de 30 agentes — cada um no seu workspace, com squads, chat, terminais e revisão num só app. Usa as assinaturas que você já tem.

https://runtallos.com/signup (macOS 13+ · Windows 10+)