Estava à tua espera. Senta, fica frio, o pai vai explicar-te como é que eu deixei de copiar código do chat para o editor e passei a ter um exército de agentes no terminal.
Primeiro: o que raio é uma CLI de IA?
CLI quer dizer command-line interface, ou seja, aquele ecrã preto onde os técnicos de informática parecem estar a fazer hacking (e às vezes estão só a fazer ls há cinco minutos).
Uma CLI de agente de código é esse ecrã preto, mas com um modelo de IA lá dentro e com ferramentas nas mãos: lê ficheiros, escreve ficheiros, pesquisa no código, corre comandos, usa o Git. Tu dizes o que queres, ele planeia, faz, vê o que deu, corrige e repete até a coisa funcionar.
A diferença para o chat é que o agente está dentro do teu projecto. Vê a estrutura, as dependências, os testes. Não está a adivinhar à distância, está a trabalhar na obra.
Porque é que isto importa (e não é só moda)
- Acaba o trabalho chato. Migrações, refactors, testes, documentação. Delega.
- Funciona onde tu já trabalhas. Terminal local, WSL, VPS por SSH. Não te prende a um editor.
- Dá para automatizar. Ferramenta de terminal entra em scripts e pipelines sem pedir licença.
- Fica tudo no Git. O agente fez asneira?
git diff, olhas, revertes, vida que segue. - Quem sabe mais, rende mais; quem está a aprender, aprende a ver. Ver um agente raciocinar e corrigir o próprio erro ensina muito.
Quem está no mercado
Há o Claude Code (Anthropic), o Codex CLI (OpenAI), o Gemini CLI (Google) e o OpenCode, de código aberto. Todos fazem a mesma ideia base. A diferença está na liberdade: as dos grandes fornecedores vivem naturalmente mais agarradas ao ecossistema deles, e o OpenCode foi feito para não depender de ninguém.
Spoiler: é por isso que eu uso o OpenCode.
Como começar (é mais fácil do que parece)
- Instala o OpenCode seguindo a documentação oficial (instalador por
curlou pacote npm). - Entra na pasta do projecto e escreve
opencode. - Liga um fornecedor com
/connecte escolhe o modelo com/models. - Corre
/init. Ele cria umAGENTS.md, o ficheiro onde escreves as regras da casa: a stack, o estilo de código, o que nunca se deve fazer. Quanto melhor escreveres isto, menos asneiras o agente faz. - Carrega no Tab para alternar de agente. O Plan pensa e planeia sem mexer nos teus ficheiros, e o Build mete as mãos na massa. Dica de ouro: planeia primeiro, lê o plano, e só depois mandas construir.
Porque é que o OpenCode é o meu
1. Qualquer modelo, de qualquer equipa
Esta é a razão principal. Posso ligar modelos de várias equipas, trocar quando aparece um melhor e usar um barato para o simples e um forte para o difícil. Saiu modelo novo? Experimento no mesmo dia, sem mudar de ferramenta e sem aprender tudo de novo.
2. O plano Go
O OpenCode Go é uma subscrição barata para modelos abertos de código. Segundo a documentação oficial, custa 5 dólares no primeiro mês e 10 dólares por mês depois (confirma sempre na página oficial, que preços mudam).
E o que eu tenho a dizer é isto: na minha experiência, os limites do plano Go duram mais do que em qualquer outra CLI que usei. Dá para trabalhar o dia inteiro sem andar a contar pedidos como quem conta moedas no fim do mês.
3. Skills à medida
Uma skill é uma pasta com um SKILL.md onde ensinas ao agente como fazer bem um tipo de tarefa. O OpenCode procura-as em .opencode/skills/<nome>/SKILL.md (projecto) e em ~/.config/opencode/skills/<nome>/SKILL.md (global), e também lê as pastas .claude/skills e .agents/skills.
O agente só carrega a skill quando precisa, por isso o contexto não fica inchado. Eu escrevo skills para as minhas convenções, o meu processo de deploy e os meus checklists. É ensinar uma vez e nunca mais repetir.
4. MCPs: dar mãos e olhos ao agente
O Model Context Protocol (MCP) é o padrão aberto que liga agentes a ferramentas externas. O OpenCode suporta servidores locais e remotos, e as ferramentas aparecem ao modelo ao lado das nativas.
Um agente que só escreve código trabalha de olhos fechados. Com um MCP de navegador, o meu agente consegue:
- abrir abas e navegar na aplicação que acabou de construir;
- testar fluxos (clicar, preencher formulários, ver se funcionou);
- ler o conteúdo da página, a consola e os pedidos de rede;
- tirar screenshots para ver como ficou, em vários tamanhos de ecrã.
Os que uso são o Playwright MCP (automação do navegador) e o Chrome DevTools MCP (consola, rede, desempenho). Configuração (sintaxe V2; na V1 os servidores ficam directamente em mcp, com enabled: true):
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"servers": {
"playwright": {
"type": "local",
"command": ["npx", "-y", "@playwright/mcp@latest"]
},
"chrome-devtools": {
"type": "local",
"command": ["npx", "-y", "chrome-devtools-mcp@latest"]
}
}
}
}
Ver o agente abrir o navegador sozinho, dar de caras com um erro, corrigir e testar outra vez é das coisas mais satisfatórias que já vi num terminal.
A minha equipa de agentes (que não pede aumento)
Os agentes do OpenCode são perfis reutilizáveis: prompt, modelo, permissões e descrição. Os subagentes correm em sessões filhas, com contexto novo, e são chamados pelo agente principal para tarefas específicas. Ou seja, dá para montar uma equipa inteira:
- Segurança: caça falhas, segredos expostos e dependências duvidosas.
- Testes: escreve e corre testes, e investiga o que falha.
- QA: percorre os fluxos como um utilizador, com o navegador.
- Responsividade: abre a app em vários tamanhos de ecrã e compara.
- Git e deploy: valida se está tudo conforme as regras que eu defini e só então sobe o código.
O segredo é que cada um tem as suas permissões. O revisor não precisa de editar nada, e o do Git precisa de comandos Git mas não de apagar a tua pasta. Exemplo de um revisor (formato V2):
---
description: Revê as alterações em busca de falhas de segurança e regressões
mode: subagent
permissions:
- action: edit
resource: "*"
effect: deny
- action: shell
resource: "*"
effect: deny
---
Revê as alterações actuais. Lista os problemas por gravidade,
com ficheiro e linha.
E um subagente de Git que pergunta antes de enviar para o remoto:
---
description: Valida o projecto contra as regras definidas e faz commit/push
mode: subagent
permissions:
- action: edit
resource: "*"
effect: deny
- action: shell
resource: "*"
effect: deny
- action: shell
resource: "git status"
effect: allow
- action: shell
resource: "git diff *"
effect: allow
- action: shell
resource: "git add *"
effect: allow
- action: shell
resource: "git commit *"
effect: allow
- action: shell
resource: "git push *"
effect: ask
---
Antes de qualquer commit, confirma que os testes passam e que as
regras do projecto foram cumpridas. Se algo falhar, não avances e
explica o motivo.
Nota técnica importante: nas permissões, a última regra que corresponder é a que vale. Por isso as regras gerais vêm primeiro e as excepções depois.
Modelos baratos que parecem magia
O que mais me surpreendeu foi ver modelos baratos a render de forma absurda. Na minha experiência, a magia não está só no modelo, está no que o rodeia:
- regras claras no
AGENTS.md; - skills com o processo certo para cada tarefa;
- tarefas pequenas, entregues ao subagente certo;
- verificação automática, com testes e navegador, em vez de acreditar às cegas.
Um modelo mediano com um bom sistema à volta ganha a um modelo excelente sem regras nem verificação. E ainda poupas dinheiro para usar o modelo caro só onde ele faz mesmo diferença.
Antes de saíres a dar superpoderes a tudo (cuidados)
- Revê sempre. O agente acelera, mas a responsabilidade continua a ser tua.
- Permissões mínimas. Usa
asknas acções sensíveis, comogit pushou comandos destrutivos. Dar shell total a um agente é entregar a chave de casa ao vizinho. - Protege os segredos. Chaves e senhas não são para o agente (nem para o modelo) verem.
- Trabalha sempre com Git e faz commits frequentes. É o teu botão de desfazer.
- Escolhe bem o fornecedor. O teu código vai para quem fornece o modelo, por isso lê a política de privacidade antes de meter código de clientes lá dentro.
Conclusão
As CLIs de agentes mudaram a forma como se faz software, e o OpenCode é a que melhor encaixa no meu jeito: qualquer modelo, skills e MCPs à minha medida, e uma equipa de agentes que segue as regras que eu escrevi. O meu OpenCode tem superpoderes porque fui eu que os configurei.
Se vais começar hoje: instala, corre /init, escreve as tuas regras, liga um MCP de navegador e cria o teu primeiro subagente. O resto vem com a prática.
Ainda a ler? Respeito. Agora vai experimentar, que o terminal não se abre sozinho.
— Sr. Saiombo
Referências
- OpenCode, agentes (V2): https://opencode.ai/v2/docs/agents/
- OpenCode, servidores MCP: https://opencode.ai/docs/mcp-servers
- OpenCode, Agent Skills: https://opencode.ai/docs/skills
- OpenCode Go: https://opencode.ai/docs/go
- Model Context Protocol: https://modelcontextprotocol.io
- Playwright MCP (Microsoft): https://github.com/microsoft/playwright-mcp
- Chrome DevTools MCP: https://github.com/ChromeDevTools/chrome-devtools-mcp
- Agent Skills (formato aberto): https://agentskills.io
- Claude Code: https://docs.claude.com/en/docs/claude-code/overview
- Codex CLI (OpenAI): https://github.com/openai/codex
- Gemini CLI (Google): https://github.com/google-gemini/gemini-cli