srsaiombo

CLIs de IA para programadores: porque o OpenCode é a minha escolha

As CLIs de agentes de código vivem no terminal, lêem o teu projecto e executam o trabalho por ti. Explico o que são, porque importam, como começar e porque o OpenCode, com skills, MCPs e subagentes especialistas, é a minha escolha.

Imagem de capa: CLIs de IA para programadores: porque o OpenCode é a minha escolha

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)

  1. Instala o OpenCode seguindo a documentação oficial (instalador por curl ou pacote npm).
  2. Entra na pasta do projecto e escreve opencode.
  3. Liga um fornecedor com /connect e escolhe o modelo com /models.
  4. Corre /init. Ele cria um AGENTS.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.
  5. 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 ask nas acções sensíveis, como git push ou 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

Achaste útil?

Leva esta ideia contigo.

Novidades sem ruído

A próxima ideia
chega à tua caixa.

Recebe um email quando sair um novo artigo. Sem frequência inventada e podes cancelar quando quiseres.

Só usamos o email para enviar novidades do blogue.