Como montar um copiloto de código para a sua equipe

Assistente de código deixou de ser novidade e virou ferramenta de trabalho. O que ainda incomoda são duas coisas: a assinatura por cabeça, que cresce com o time, e o fato de que o seu código-fonte sai da empresa a cada tecla digitada.

Dá para resolver os dois. Este guia monta um copiloto para a equipe inteira em duas configurações — uma que você liga em 15 minutos e cobra por uso, outra que roda numa GPU sua com controle total — e mostra a conta de qual compensa no seu tamanho de time.

Antes de tudo: são dois produtos, não um

Quase todo mundo trata "copiloto" como uma coisa só, e é aí que a montagem dá errado. São dois modos de uso com exigências opostas:

A recomendação honesta: comece pelo chat. Ele entrega a maior parte do valor (explicar código, escrever teste, refatorar, revisar diff), é o que menos custa e liga em minutos. Autocompletar é ótimo, mas é o modo caro e chato de operar — deixe para a segunda fase.

Configuração 1: chat e agente por token (15 minutos)

Vamos usar o Continue, que é aberto, roda em VS Code e JetBrains, e aceita qualquer endpoint compatível com a API da OpenAI — que é o caso da API da GPUBrasil.

Passo 1: a chave

No painel, em Chaves de API, gere uma chave. O ideal é uma chave por desenvolvedor: assim você vê o consumo individual no painel e revoga a de quem sai da empresa sem mexer no resto do time.

Passo 2: instalar e apontar

Instale a extensão Continue e edite ~/.continue/config.json:

{
  "models": [
    {
      "title": "Padrão (código e chat)",
      "provider": "openai",
      "model": "gpub-plus",
      "apiBase": "https://gpubrasil.com.br/v1",
      "apiKey": "gpub_live_suachaveaqui"
    },
    {
      "title": "Econômico (perguntas rápidas)",
      "provider": "openai",
      "model": "gpub-fast",
      "apiBase": "https://gpubrasil.com.br/v1",
      "apiKey": "gpub_live_suachaveaqui"
    },
    {
      "title": "Máximo (base inteira, refatoração grande)",
      "provider": "openai",
      "model": "gpub-max",
      "apiBase": "https://gpubrasil.com.br/v1",
      "apiKey": "gpub_live_suachaveaqui"
    }
  ],
  "allowAnonymousTelemetry": false
}

Pronto. Ctrl+L abre o chat com o arquivo aberto no contexto; Ctrl+I edita a seleção com instrução em linguagem natural.

Passo 3: mesma coisa nos outros editores

• JetBrains: a mesma extensão Continue, mesmo arquivo de configuração.
• Zed: em Settings, defina um provedor compatível com OpenAI apontando para https://gpubrasil.com.br/v1.
• Neovim / terminal: o Aider é excelente e trabalha direto sobre o Git, criando commits por alteração.

pip install aider-chat

export OPENAI_API_BASE="https://gpubrasil.com.br/v1"
export OPENAI_API_KEY="gpub_live_suachaveaqui"

aider --model openai/gpub-plus src/servico.py
# "adicione tratamento de erro e um teste para o caso de timeout"

Quanto isso custa por desenvolvedor

Uso realista de chat: 40 interações por dia, cerca de 6 mil tokens de entrada (o arquivo mais o contexto) e 700 de saída por interação.

Para comparação, uma assinatura corporativa dos assistentes de mercado fica em torno de US$ 19 por desenvolvedor por mês — perto de R$ 115 com o dólar em R$ 6. Com o gpub-plus, o mesmo time de 10 gasta R$ 61 no total, e você paga só quem realmente usou.

A economia não é o argumento mais forte, no entanto. O mais forte é o próximo.

Configuração 2: modelo próprio numa GPU dedicada

Duas razões levam à segunda configuração, e nenhuma é preço:

• Autocompletar precisa de latência baixa. Abaixo de 300 ms por sugestão. Isso é difícil de garantir por qualquer API pública e fácil de garantir com o modelo servido perto de você.
• Governança. Numa instância dedicada, o modelo, os pesos, os logs e os prompts estão sob o seu controle — não existe API de terceiro no caminho do seu código-fonte. É o argumento que costuma destravar a aprovação de segurança, e ele é sobre controle, não sobre onde a máquina fica.

Passo 1: subir o servidor de modelo

O template vLLM sobe em 1 clique e serve uma interface compatível com a da OpenAI. Para autocompletar, escolha um modelo de código pequeno com suporte a fill-in-the-middle — é o que permite completar no meio do arquivo, olhando o que vem antes e depois do cursor.

Passo 2: apontar o Continue para as duas fontes

A configuração madura usa autocompletar local e chat por token. Você paga GPU só pelo que exige latência, e usa modelo grande no que exige qualidade:

{
  "models": [
    {
      "title": "Chat (por token)",
      "provider": "openai",
      "model": "gpub-plus",
      "apiBase": "https://gpubrasil.com.br/v1",
      "apiKey": "gpub_live_suachaveaqui"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Autocompletar (GPU dedicada)",
    "provider": "openai",
    "model": "modelo-de-codigo-servido",
    "apiBase": "http://SEU_IP:8000/v1",
    "apiKey": "chave-interna"
  },
  "tabAutocompleteOptions": {
    "debounceDelay": 250,
    "maxPromptTokens": 1024,
    "multilineCompletions": "auto"
  }
}

O debounceDelay é o parâmetro que decide o custo e o incômodo: baixo demais dispara uma chamada por tecla; alto demais e a sugestão chega quando o dev já digitou a linha. 250 ms é um bom ponto de partida.

Passo 3: não exponha o servidor na internet

Um endpoint de LLM aberto vira consumo de terceiros na sua conta em questão de horas. Duas formas de fechar:

• Túnel SSH por desenvolvedor — simples e seguro; nada exposto:

ssh -N -L 8000:localhost:8000 gpu-copiloto
# agora, no config: "apiBase": "http://localhost:8000/v1"

• Proxy com autenticação — para times maiores. O template LiteLLM Proxy resolve: chave por desenvolvedor, limite de uso, registro de consumo e um único ponto de entrada que pode rotear para o modelo local ou para a API por token conforme a tarefa.

Regras de uso que valem escrever

A parte que quase ninguém documenta e que separa adoção de bagunça:

• Revisão continua obrigatória. Código gerado entra por pull request como qualquer outro. O assistente não é autor, é ferramenta.
• Nunca cole segredo no chat. Vale para qualquer assistente, inclusive o seu. Configure .continueignore para excluir .env, chaves e diretórios sensíveis.
• Desligue a telemetria. allowAnonymousTelemetry: false. Padrão de fábrica costuma vir ligado.
• Escolha do modelo é decisão de custo. Ensine o time: pergunta rápida no barato, refatoração grande no caro. A diferença é de 36 vezes.
• Teste gerado por IA sem asserção é teste que passa sempre. Revise a asserção, não só a execução.
• Uma chave por pessoa. Consumo rastreável e desligamento limpo na saída.

Medindo se está valendo

Depois de um mês, olhe três números — e não confie na percepção, que é sempre otimista:

• Custo por desenvolvedor ativo (não por cadastrado). Se metade do time não usa, a média engana.
• Distribuição de uso por modelo. Se 80% das chamadas vão para o modelo mais caro, há dinheiro parado na mesa.
• Onde o time realmente usa. Se é só para escrever teste e explicar código legado, ótimo — mas então você não precisa do modelo mais caro do catálogo.

Problemas comuns

Conclusão

Copiloto de código não precisa ser assinatura por cabeça nem projeto de infraestrutura. Comece pelo chat por token — 15 minutos de configuração, alguns reais por desenvolvedor por mês — e só monte a GPU dedicada quando aparecer uma razão concreta: autocompletar com latência baixa, ou uma exigência de governança que peça controle sobre modelo, pesos e logs.

Os dois arranjos convivem no mesmo editor. Essa é a vantagem de tudo falar o mesmo protocolo: a decisão deixa de ser arquitetural e vira uma linha de configuração que você muda quando a conta mandar.

Continue: GPU como máquina de desenvolvimento · LiteLLM Proxy · servir modelo com vLLM