Como usar o GitHub Copilot CLI: guia passo a passo

Para usar o GitHub Copilot CLI, instale-o (npm install -g @github/copilot, Homebrew, WinGet ou o script de instalação), rode copilot na pasta do projeto, confirme que confia na pasta, faça login com /login e descreva a tarefa em linguagem natural. O Copilot lê seu código, propõe edições e comandos e pergunta antes de rodar qualquer coisa.

Esse é o ciclo básico. Este guia cobre o que você precisa depois da primeira sessão: qual plano é necessário, uso interativo e programático, permissões de ferramentas, os comandos de barra que vale conhecer, modelos, servidores MCP e instruções personalizadas. Tudo aqui segue a documentação oficial do GitHub em docs.github.com, de outubro de 2026. Se você ainda está escolhendo um agente, Copilot CLI vs Claude Code compara os dois lado a lado; este post é o passo a passo.

O que é o Copilot CLI

O Copilot CLI é o agente de código do GitHub para o terminal. Ele trabalha na pasta onde você o inicia: pode ler e mudar arquivos, rodar comandos de shell e falar com o GitHub por um servidor MCP do GitHub embutido, então também consegue olhar issues e pull requests. Roda em Linux, macOS e Windows (PowerShell e WSL).

Passo 1: confira seu plano

Em outubro de 2026, a página de planos do GitHub diz que todos os planos do Copilot incluem o Copilot CLI. O uso é contado em GitHub AI Credits, e a velocidade com que você os gasta depende do modelo e do volume de trabalho.

Se o seu Copilot vem de uma organização, um admin pode desativar o CLI, então confira isso primeiro se ele se recusar a iniciar. O post de comparação se aprofunda em créditos e preços.

Passo 2: instale o Copilot CLI

No Windows você precisa do PowerShell 6 ou mais recente. Se a sua configuração do npm tem ignore-scripts definido, instale com npm_config_ignore_scripts=false npm install -g @github/copilot. /update dentro de uma sessão atualiza o CLI.

Passo 3: inicie e faça login

cd ~/code/my-project
copilot

Na primeira vez que você inicia o Copilot em uma pasta, ele pergunta se você confia nos arquivos dela. Você pode confiar só nesta sessão, confiar e lembrar a escolha, ou dizer não. Os diretórios confiáveis são onde o Copilot pode ler, mudar e executar coisas, então inicie-o na pasta do projeto, não no seu diretório home.

Se você não estiver logado, digite /login e siga o fluxo no navegador. Em um shell normal, copilot login faz o mesmo, com --device-code para máquinas sem navegador. Para automação, o Copilot lê um token de COPILOT_GITHUB_TOKEN, depois GH_TOKEN, depois GITHUB_TOKEN; um fine-grained personal access token precisa da permissão “Copilot Requests”. /user mostra ou troca a conta logada e /logout encerra a sessão.

Passo 4: trabalhe no modo interativo

Digite o que você quer:

Find where we validate email addresses, add a test for addresses with
a plus sign, and run the test suite.

Alguns truques de entrada:

• @path/to/file coloca um arquivo no prompt.
• !command roda um comando de shell diretamente, sem enviá-lo ao modelo.
• Shift+Tab alterna os modos. No plan mode, o Copilot faz perguntas de esclarecimento e monta um plano antes de escrever código. /plan faz o mesmo a partir do prompt.
• /autopilot deixa o Copilot continuar trabalhando sozinho até a tarefa terminar, e /ask (ou /btw) faz uma pergunta paralela sem tirar a tarefa do rumo.

Para qualquer coisa que mexa em mais de um ou dois arquivos, planeje antes:

/plan Split the 900-line OrderService into smaller services. Keep the
public API the same and list every file you will touch.

Passo 5: aprovações e permissões de ferramentas

Quando o Copilot quer rodar uma ferramenta que pode mudar algo (um comando de shell, uma escrita de arquivo, um acesso a URL), ele pergunta. Você pode aprovar uma vez, aprovar essa ferramenta pelo resto da sessão, ou dizer não e explicar o que fazer no lugar.

Para decidir de antemão, use padrões de permissão no formato Kind(argument):

# git is fine, pushing is not
copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

# allow everything except deleting files and pushing
copilot --allow-all-tools --deny-tool='shell(rm)' --deny-tool='shell(git push)'

As regras de negação sempre vencem, até sobre --allow-all. Dentro de uma sessão, /permissions alterna entre os modos de permissão (default, assisted, allow-all) e /permissions show mostra o modo atual; /sandbox enable liga o sandbox. --allow-all (alias --yolo) remove todas as perguntas, então guarde-o para containers descartáveis. Segurança de agentes de código com IA explica por quê.

Passo 6: uso programático com -p

Para scripts e CI, -p roda um prompt e sai. -s imprime só a resposta e, como não tem ninguém para aprovar, você permite as ferramentas de antemão:

copilot -p 'Write a commit message in plain text for the staged changes' \
  -s --allow-tool='shell(git:*)'

copilot -p 'Write unit tests for src/utils/validators.ts' \
  --allow-tool='write, shell(npm:*), shell(npx:*)'

Você também pode mandar um prompt por pipe: echo "Explain this file: ./complex.ts" | copilot. Extras úteis: --no-ask-user impede o Copilot de fazer perguntas, --output-format=json emite linhas JSON e --share=PATH salva a sessão em Markdown. No fim de uma execução, o Copilot imprime uma dica copilot --resume=SESSION-ID para você continuar no modo interativo.

No GitHub Actions, coloque em COPILOT_GITHUB_TOKEN um token com a permissão Copilot Requests:

- name: Coverage summary
  env:
    COPILOT_GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
  run: copilot -p "Run the test suite and produce a coverage summary" -s --allow-tool='shell(npm:*), write' --no-ask-user

Passo 7: comandos de barra que vale conhecer

No shell, copilot --resume (ou --continue para a sessão mais recente) retoma de onde você parou, e -n NAME dá nome a uma sessão para você retomá-la pelo nome.

Passo 8: escolha um modelo

/model abre o seletor de modelos; --model=NAME ou a variável de ambiente COPILOT_MODEL o define na inicialização, e auto deixa o Copilot escolher. --effort (ou --reasoning-effort) define low, medium, high, xhigh ou max nos modelos que suportam. Modelos diferentes gastam AI Credits em ritmos diferentes, e contextos longos e mais raciocínio custam mais, então vale olhar o /usage de vez em quando.

Você também pode trazer seu próprio provedor de modelos. Defina COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE (openai, azure ou anthropic), COPILOT_PROVIDER_API_KEY e COPILOT_MODEL. Isso funciona com o Ollama para modelos locais, desde que o modelo suporte tool calling e streaming; o GitHub recomenda uma janela de contexto de 128k tokens ou mais. copilot help providers lista os detalhes.

Passo 9: adicione servidores MCP

O servidor MCP do GitHub já vem configurado. Para adicionar outros, use o CLI ou /mcp add em uma sessão:

# a local server started with a command
copilot mcp add my-server -- npx -y @example/mcp-server

# a remote server over HTTP
copilot mcp add --transport http my-remote https://mcp.example.com/mcp

Os servidores ficam em ~/.copilot/mcp-config.json, e um .mcp.json no repositório adiciona servidores para aquele projeto:

{
  "mcpServers": {
    "my-internal-server": {
      "command": "npx",
      "args": ["-y", "@example/mcp-server"],
      "tools": ["*"]
    }
  }
}

tools decide quais ferramentas do servidor o Copilot pode chamar; ["*"] significa todas. copilot mcp list mostra o que está configurado, e --additional-mcp-config adiciona servidores para uma única sessão. Novo no MCP? Comece por o que é um servidor MCP.

Passo 10: instruções personalizadas

O Copilot CLI junta instruções de vários lugares:

• AGENTS.md, CLAUDE.md e GEMINI.md na raiz do repositório e na pasta atual
• .github/copilot-instructions.md
• .github/instructions/**/*.instructions.md, que podem ser limitados a certos caminhos com o frontmatter applyTo:
• ~/.copilot/copilot-instructions.md para regras pessoais em todos os projetos

/init (ou copilot init) escreve um .github/copilot-instructions.md inicial com base no seu repositório. Mantenha-o curto: comandos de build e teste, convenções e o que o agente não pode fazer. Se você já mantém um AGENTS.md para outros agentes, o Copilot vai usá-lo como está. CLAUDE.md e AGENTS.md tem dicas para escrever regras que os agentes realmente seguem. Para iniciar uma sessão sem nenhum desses arquivos, passe --no-custom-instructions.

Armadilhas comuns

• Iniciar na pasta home. Confie só no diretório do projeto; o acesso a arquivos do Copilot segue os diretórios confiáveis.
• Permitir demais no CI. --allow-all em um pipeline com secrets é pedir problema. Permita só as ferramentas de que o job precisa e negue git push, a menos que o job faça push.
• Esquecer a permissão do token. Um personal access token sem “Copilot Requests” não autentica, e tokens de propriedade de organizações não são suportados.
• Uma sessão sem fim. Conversas longas custam mais créditos. Use /compact ou /clear entre tarefas sem relação.
• Esperar ferramentas MCP sem tools. Uma entrada de servidor precisa de uma lista tools; use ["*"] para expor tudo.

Rodando o Copilot CLI no AgentVera

O AgentVera é um app desktop para macOS, Windows e Linux que roda agentes de CLI lado a lado em terminais reais, usando suas próprias instalações e logins. O Copilot CLI é um dos agentes suportados; a página Copilot CLI no AgentVera tem os detalhes:

• Seu login do GitHub. O Copilot usa o próprio login. Se estiver deslogado, rode /login no terminal do agente; uma assinatura do Copilot que você já tem basta.
• Modelo e esforço por agente. O modelo é passado com --model e o esforço, de minimal a max, com --reasoning-effort.
• Sessões que voltam. Cada agente ganha seu próprio ID de sessão, e uma sessão salva reabre com --resume depois de reiniciar. /compact funciona como sempre.
• MCP sem editar configuração. Servidores do gerenciador de MCP do AgentVera e do seu navegador de servidores são adicionados com --additional-mcp-config a cada inicialização, então seu mcp-config.json fica intocado. O papel do agente é adicionado como uma pasta extra de instruções.
• Painéis, worktrees e revisão. Rode o Copilot na grade do workspace ao lado do Claude Code ou do Aider, dê a cada agente seu próprio worktree pelo painel Git e receba revisão automática de código no fim de cada turno. Agentes Copilot também funcionam em flows (Pro e Team), broadcasts e tarefas agendadas.

A grade, os worktrees, a revisão de código e o gerenciador de MCP estão no plano gratuito. Baixe o AgentVera para experimentar.

Concluindo

Instale o Copilot CLI, rode copilot no seu projeto, confie na pasta e faça login com /login. Planeje mudanças maiores com Shift+Tab ou /plan, permita só as ferramentas com que você se sente confortável e use copilot -p com regras --allow-tool explícitas para scripts e CI. Coloque suas regras no AGENTS.md ou no .github/copilot-instructions.md e adicione servidores MCP quando precisar. Se você também quer um agente centrado no git que funcione com qualquer modelo, leia como usar o Aider.