# Como usar o GitHub Copilot CLI: guia passo a passo

URL: https://agentvera.dev/pt/blog/how-to-use-copilot-cli/ · Publicado: 2026-10-27

Como usar o GitHub Copilot CLI: instalar, fazer login, escolher o plano, usar no modo interativo ou com -p, definir permissões, trocar de modelo, MCP e regras.

**Resumo:**

- Instale o Copilot CLI com npm, Homebrew, WinGet ou o script de instalação, rode copilot na pasta do projeto, confie na pasta e faça login com /login.
- O Copilot pergunta antes de rodar ferramentas; padrões de --allow-tool e --deny-tool como shell(git:*) definem as permissões, e copilot -p roda um único prompt para scripts e CI.
- /model troca de modelo, copilot mcp add conecta servidores MCP, e AGENTS.md ou .github/copilot-instructions.md guardam as regras do seu projeto.

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](/pt/blog/copilot-cli-vs-claude-code/ "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](/pt/glossary/coding-agent/ "O que é um 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.

| Plano | Preço | Observações |
| --- | --- | --- |
| Copilot Free | Grátis | Cota limitada de AI Credits |
| Copilot Student | Grátis | Para estudantes verificados |
| Copilot Pro | US$ 10/mês | Mais créditos |
| Copilot Pro+ | US$ 39/mês | Mais créditos |
| Copilot Max | US$ 100/mês | A maior cota pessoal |
| Business / Enterprise | US$ 19 / US$ 39 por usuário | Gerenciado por uma organização |

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](/pt/blog/copilot-cli-vs-claude-code/ "Copilot CLI vs Claude Code") se aprofunda em créditos e preços.

## Passo 2: instale o Copilot CLI

| Método | Comando |
| --- | --- |
| npm (Node.js 22 ou mais recente) | `npm install -g @github/copilot` |
| Homebrew (macOS, Linux) | `brew install --cask copilot-cli` |
| WinGet (Windows) | `winget install GitHub.Copilot` |
| Script de instalação (macOS, Linux) | `curl -fsSL https://gh.io/copilot-install \| bash` |

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

```bash
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:

```text
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:

```text
/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)`:

| Padrão | Corresponde a |
| --- | --- |
| `shell(git:*)` | Qualquer comando `git` (`git status`, `git log`…) |
| `shell(git push)` | Exatamente `git push` |
| `write` ou `write(src/*.ts)` | Escrita de arquivos, opcionalmente limitada a um caminho |
| `read(.env)` | Leitura de um arquivo específico |
| `url(github.com)` | Acesso a um domínio |
| `MyMCP(create_issue)` | Uma ferramenta de um servidor MCP |

```bash
# 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](/pt/blog/ai-coding-agent-security/ "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:

```bash
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:

```yaml
- 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

| Comando | O que faz |
| --- | --- |
| `/model` | Escolhe um modelo, ou `auto` |
| `/plan`, `/autopilot` | Planeja antes, ou deixa rodar até o fim |
| `/review` | Revisa as mudanças atuais |
| `/diff` | Mostra o que mudou |
| `/undo` (`/rewind`) | Volta para um ponto anterior |
| `/compact` | Resume a conversa para liberar contexto |
| `/context`, `/usage` | Mostra o uso de contexto e de créditos |
| `/clear` (`/new`) | Começa uma conversa nova |
| `/resume` | Continua uma sessão anterior |
| `/pr` | Vê, cria ou corrige um pull request |
| `/delegate` | Passa a tarefa para o Copilot no GitHub, que abre um pull request |
| `/mcp` | Lista, adiciona e gerencia servidores MCP |
| `/init` | Cria um arquivo de instruções personalizadas |
| `/permissions` | Muda as regras de aprovação |

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:

```bash
# 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:

```json
{
  "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](/pt/blog/what-is-mcp-server/ "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](/pt/blog/claude-md-agents-md/ "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](/pt/agents/copilot-cli/ "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](/pt/features/mcp-manager/ "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](/pt/features/workspace/ "Workspace") ao lado do Claude Code ou do Aider, dê a cada agente seu próprio worktree pelo [painel Git](/pt/features/git-and-github/ "Git e GitHub") e receba [revisão automática de código](/pt/features/code-review/ "Revisão 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](/pt/download/ "Baixar 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](/pt/blog/how-to-use-aider/ "Como usar o Aider").

## Perguntas frequentes

**Preciso de um plano pago para usar o Copilot CLI?** Não. Em outubro de 2026, o GitHub diz que todos os planos do Copilot incluem o Copilot CLI, inclusive o Copilot Free e o Copilot Student. O Free vem com uma cota limitada de GitHub AI Credits; Pro, Pro+, Max, Business e Enterprise incluem mais. Se você recebe o Copilot por uma organização, um admin pode desativar o CLI.

**Como fazer login no Copilot CLI?** Rode copilot e digite /login, ou rode copilot login no seu shell. Ele abre um login no navegador com sua conta do GitHub. Para scripts e CI, você pode colocar em COPILOT_GITHUB_TOKEN um fine-grained personal access token com a permissão Copilot Requests.

**Como fazer o Copilot CLI parar de pedir aprovação toda vez?** Escolha “Yes, and approve for the rest of the session” quando ele perguntar, ou permita ferramentas específicas de antemão com --allow-tool, por exemplo --allow-tool='shell(git:*)'. --allow-all remove todas as perguntas, o que é arriscado fora de um sandbox ou container. Uma regra --deny-tool sempre vence uma regra de permissão.

**O Copilot CLI pode usar modelos que não são do GitHub?** Sim. Além dos modelos do /model, o Copilot CLI suporta provedores com sua própria key. Defina COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE, COPILOT_PROVIDER_API_KEY e COPILOT_MODEL para usar um endpoint compatível com OpenAI, Azure ou Anthropic, inclusive um modelo local via Ollama.

**Onde coloco as instruções do projeto para o Copilot CLI?** No .github/copilot-instructions.md ou no AGENTS.md na raiz do repositório. O Copilot CLI também lê CLAUDE.md, GEMINI.md e arquivos em .github/instructions/. Regras pessoais vão em ~/.copilot/copilot-instructions.md. Rode /init para gerar um arquivo inicial.

---

**Sobre o AgentVera.** AgentVera é um app desktop para macOS, Windows e Linux, desenvolvido pela Solviera Teknoloji. Ele roda 18 agentes de programação com IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) lado a lado, por projeto, em terminais reais com as instalações e logins de CLI do próprio usuário. O plano gratuito tem agentes ilimitados. Baixar: https://agentvera.dev/pt/download/ · Preços: https://agentvera.dev/pt/pricing/