Tutorial da CLI do GitHub Copilot: Recursos, instalação e casos de uso

O GitHub Copilot CLI traz assistência de IA direto pro terminal pra ajudar os desenvolvedores a escrever código, automatizar tarefas e gerenciar fluxos de trabalho usando linguagem natural. Ele amplia as capacidades do Copilot além do editor e transforma a linha de comando em um espaço de trabalho inteligente e sensível ao contexto.

Este guia mostra tudo o que você precisa saber: como funciona a CLI do Copilot, como instalar e configurar e como usar em situações reais.

Pra usar o Copilot CLI de forma eficaz, você precisa estar familiarizado com a própria CLI. A Introdução ao Shell constrói a memória muscular fundamental que a CLI do Copilot visa automatizar.

O que é o GitHub Copilot CLI?

O GitHub Copilot CLI é uma ferramenta de linha de comando que traz assistência de IA direto para o seu terminal. Você pode pedir comandos, entender scripts complexos e resolver problemas diretamente do seu shell. Em vez de interromper seu fluxo para folhear a documentação ou memorizar sinalizadores obscuros, você pode simplesmente descrever o que deseja alcançar.

Você também pode gerenciar repositórios remotos, abrir issues, criar pull requests e trabalhar com o GitHub Actions usando comandos em linguagem natural. Isso reduz bastante a troca de contexto, permitindo que você faça quase tudo o que normalmente faz no site do GitHub direto da CLI.

Entendendo a CLI do GitHub Copilot

A CLI do GitHub Copilot está mudando de um simples auxiliar de linha de comando para um agente mais autônomo. Esta seção fala sobre essa mudança e suas novas possibilidades.

Evolução da extensão CLI para um agente autônomo

A primeira versão do suporte à IA para terminais veio com a extensão gh-copilot. Funcionava como um complemento para a CLI do GitHub. Você pode digitar um prompt em linguagem natural e receber um comando ou script que se adapte à tarefa que você descreveu. Por exemplo:

gh copilot generate "Write a bash script that deletes merged branches"

#!/bin/bash
git branch --merged main | grep -v "main" | xargs git branch -d

Você pode copiar o resultado e rodar no terminal. Lembre-se de que você ainda precisa copiar e executar por conta própria. E se a ferramenta fizesse isso sozinha? É isso que a nova CLI do GitHub Copilot traz.

Pra acompanhar os avanços atuais da IA, o GitHub deixou de usar a extensão antiga em 25 de outubro de 2025 e lançou a nova CLI Copilot. Essa versão oferece uma experiência muito mais interativa no terminal. Ele entende o contexto, executa fluxos de trabalho com várias etapas, aplica alterações de código e ajuda a depurar problemas diretamente da linha de comando.

Extensão Copilot IDE vs Copilot CLI

A CLI do Copilot complementa a extensão IDE do Copilot, e as duas usam os modelos de IA do GitHub para dar suporte a diferentes partes do fluxo de trabalho de desenvolvimento. No editor, Copilot te ajuda a escrever, refatorar e completar o código. No terminal, você usa o Copilot CLI para fluxos de trabalho baseados em terminal.

Por exemplo, você pode usar o Copilot no VS Code para criar um Dockerfile, depois mudar para o terminal e pedir ao Copilot CLI para construir a imagem e colocar a aplicação em um contêiner.

O que há de novo no GitHub Copilot CLI?

Esta versão traz um conjunto de recursos incríveis que transformam a CLI de um assistente passivo em um parceiro de desenvolvimento proativo e autônomo.

Capacidades de agência

A antiga assistência gh só conseguia explicar o código ou gerar scripts básicos de shell. A nova CLI do Copilot vai além disso. É um agente autônomo que planeja e faz tarefas com várias etapas. Ele pode depurar código, modificar arquivos, criar novas estruturas de projeto e lidar com fluxos de trabalho complexos inteiramente a partir do terminal.

Acesso aos modelos mais recentes

A nova CLI Copilot te dá acesso aos modelos mais recentes da Anthropic, OpenAI, Google e outras empresas. Essa abordagem multimodelo oferece mais flexibilidade do que ferramentas de um único provedor, como a CLI Gemini ou a CLI OpenAI Codex.

Ele usa o Claude Sonnet 4.5 como modelo padrão, e você pode trocar de modelo a qualquer momento executando o comando /model e escolhendo uma nova opção da lista.

Extensibilidade com tecnologia MCP

O Protocolo de Contexto de Modelo (MCP) permite que a CLI acesse conjuntos de dados internos, bases de conhecimento específicas e gere soluções específicas do domínio para o seu caso de uso. 

O Copilot CLI inclui um servidor GitHub MCP pré-configurado, para que ele interaja facilmente com o GitHub.com e gerencie repositórios remotos diretamente do terminal. Você também pode conectar a CLI do Copilot a servidores MCP personalizados e buscar o contexto de suas ferramentas ou bancos de dados proprietários.

Gerenciamento de sessão

Quando você inicia a CLI do Copilot, você entra em uma sessão que fica ativa até você sair. Dentro de uma sessão, o Copilot lembra e cria contexto com cada interação. 

Por exemplo, você pode pedir ao Copilot para revisar o resultado da sua última solicitação, estender um script que ele acabou de gerar ou aplicar alterações de acompanhamento sem repetir todo o contexto em cada prompt.

Como acessar o GitHub Copilot CLI

Você pode rodar a CLI do Copilot no macOS, Linux ou Windows e conectá-la aos seus repositórios, fluxos de trabalho e configurações organizacionais. Veja como a arquitetura funciona e o que você precisa para executá-la.

O que você precisa para usar o GitHub Copilot CLI

Você precisa de três pré-requisitos antes de poder usar a CLI do GitHub Copilot:

• Uma conta GitHub Copilot: O GitHub tem planos diferentes pra quem tá começando e pra empresas, além de um plano básico de graça com 50 solicitações de chat por mês. Escolha o plano que melhor atende às suas necessidades e ative o GitHub Copilot na sua conta.
• Node.js versão 22 ou mais recente: O GitHub cria e distribui o Copilot CLI como um aplicativo Node.js, então você precisa instalar o Node.js 22 ou mais recente no seu ambiente.
• Versão 10 ou mais recente do npm: Como o aplicativo roda no Node.js, o npm é o gerenciador de pacotes padrão. Instale o npm 10 ou uma versão mais recente para gerenciar a CLI do Copilot.

Plataformas operacionais compatíveis e detalhes do ambiente

Tem algumas coisas que você precisa lembrar ao acessar o GitHub Copilot CLI, dependendo do sistema operacional.

Linux e macOS

O GitHub Copilot CLI é totalmente compatível com Linux e macOS. Ele roda nativamente no bash e no zsh, e as duas plataformas lidam com Node.js, globais npm e integrações de shell sem problemas. Se você quer a configuração mais estável do Copilot CLI com compatibilidade total de recursos, o Linux e o macOS são os melhores.

Windows

No Windows, a melhor maneira de rodar a CLI do Copilot é usando o WSL. O WSL oferece um ambiente Linux completo dentro do Windows, para que você tenha a mesma estabilidade e compatibilidade de shell que encontraria em sistemas Linux nativos.

A CLI do Copilot também funciona no Windows PowerShell nativo, mas essa opção ainda está em fase experimental. É preciso ter o PowerShell 6 ou mais recente, mas mesmo a versão mais recente do Windows 11 já vem com o Windows PowerShell 5.1. Então, você precisa instalar manualmente o PowerShell 6 ou mais recente se quiser usar o PowerShell nativo.

Configurando o GitHub Copilot CLI: Processo de instalação passo a passo

Vamos começar com o GitHub Copilot CLI.

Passo 1: Confira os pré-requisitos

Verificar os pré-requisitos obrigatórios evita a maioria das falhas de instalação, então comece por aí. Dá uma olhada nas versões do Node.js e do npm executando:

node --version
npm --version

Você também precisa de uma conta no GitHub com uma assinatura ativa do Copilot. Se algum pré-requisito falhar, conserte-o antes de continuar para evitar erros de instalação.

Passo 2: Instalar o Copilot CLI

Instale a CLI oficial do Copilot:

npm install -g @github/copilot

Você pode conferir se a instalação deu certo executando:

--version

Se o comando mostrar um número de versão como na imagem acima, você instalou a CLI do Copilot direitinho.

Passo 3: Autenticar GitHub

Se é a primeira vez que você faz isso, precisa se autenticar no GitHub seguindo os passos abaixo:

1. Execute o comando: ` gh auth login`.

2. Quando o GitHub CLI perguntar: “Onde você usa o GitHub?”, selecione GitHub.com e aperte Enter.

3. Quando perguntar: Qual é o seu protocolo preferido para operações Git neste host? Selecione HTTPS e aperte Enter.

4. Quando perguntarem por um método de autenticação, escolha“Fazer login com um navegador da web”.

A CLI do GitHub mostra um código único e uma URL do GitHub. Acesse o URL, digite o código único, aprove a solicitação de login e confirme o acesso à sua conta do GitHub.

Depois de aprovar a solicitação, volte ao seu terminal e verifique o login executando gh auth status. Se aparecer o seu nome de usuário do GitHub, você se autenticou com sucesso.

Usando o GitHub Copilot CLI

Para iniciar o GitHub Copilot CLI após a autenticação, siga estas etapas:

1. Abra seu terminal e vá até o repositório de código onde você quer usar a CLI do Copilot.

2. Digite copilot e aperte Enter. Isso inicia um modo interativo onde você pode fazer perguntas complementares em uma única sessão.

Você também pode executar um prompt único, por exemplo, copilot -p “explain what this function does: [function_name]”. Aqui, a CLI gera a explicação e fecha a sessão na hora.

Principais recursos da CLI do GitHub Copilot

Tem uns recursos bem legais na CLI do Copilot que ajudam nos fluxos de trabalho dos agentes. Vamos ver como funcionam na prática.

Execução de tarefas com agentes autônomos

A CLI do Copilot usa uma arquitetura baseada em agente que entende seu comando, planeja as ações necessárias e executa tarefas de várias etapas diretamente no terminal.

O agente pode dividir instruções complexas e organizar tarefas que envolvem ler arquivos, gerar scripts, transformar dados ou encadear várias operações automaticamente. 

Deixa eu te mostrar como funciona na prática:

Automatizando verificações pré-implantação usando o GitHub Copilot CLI

Pedi ao Copilot para criar um script que automatiza as verificações pré-implantação. O Copilot deu uma olhada no repositório, criou um novo arquivo (deploy_prep.sh) e escreveu um script que faz verificações comuns, como checar se o Git tá limpo, rodar uma compilação Gradle e criar uma imagem Docker.

Depois que eu aceitei a diferença, o Copilot automaticamente adicionou o script ao repositório. Isso mostra como o agente lida com todo o fluxo de trabalho, desde entender o prompt até criar o arquivo e escrever o script completo.

Integração nativa do terminal e preservação do fluxo de trabalho

A CLI do Copilot roda nativamente no terminal e mantém todo o seu fluxo de trabalho em um só lugar. Você pode planejar tarefas, gerar código e executar comandos sem precisar trocar de ferramenta.

A CLI também mantém o contexto da sessão, então ela lembra suas etapas anteriores enquanto você trabalha. Essa continuidade facilita o gerenciamento de tarefas com várias etapas e a resolução de problemas complexos.

Integração com o GitHub e contexto do repositório

A CLI do Copilot se integra direto com o ecossistema GitHub, te dando acesso aos seus repositórios remotos, branches e fluxos de trabalho a partir do terminal.

Essa integração simplifica as operações do GitHub. Você pode criar pull requests, revisar diffs ou corrigir problemas em aberto com prompts simples em linguagem natural. Por exemplo, você pode pedir para a CLI criar um novo PR com um resumo das suas alterações, e ela vai preparar a solicitação, gerar a descrição e enviá-la para o GitHub.com.

Modos operacionais da CLI do GitHub Copilot

Para te dar o nível certo de controle para diferentes tarefas, a CLI está organizada em três modos operacionais diferentes: modo perguntar, modo editar e modo agente.

Modo perguntar

No modo “Perguntar”, você pode pedir definições, exemplos, comparações ou orientações passo a passo, e o Copilot responde de forma coloquial.

Por exemplo, se você não tem certeza de como uma flag funciona, o que um pipeline faz ou por que um script está falhando, o modo “Ask” te dá uma explicação direta sem sair do terminal. 

Modo de edição

Quando você ativa o Copilot no modo “Editar”, ele analisa seu projeto, identifica os arquivos que precisam de atualizações e gera as alterações. Você dá uma olhada nas diferenças no terminal e aprova elas.

Você pode usá-lo para refatorar funções, atualizar arquivos de configuração, renomear variáveis em um projeto ou migrar código para novos padrões. 

Modo agente

O modo agente é quando o Copilot CLI passa de ajudar nas tarefas para executá-las sozinho. O agente entende o que você quer, cria um fluxo de trabalho com várias etapas, faz cada uma delas, dá uma olhada nos resultados e faz os ajustes que forem precisos.

Esse modo cuida das tarefas que precisam de vários comandos ou planejamento manual. Por exemplo, o agente pode configurar um ambiente de desenvolvimento criando diretórios, gerando arquivos e instalando dependências.

Recursos avançados da CLI do Copilot 

Depois de falar sobre os recursos principais e os modos operacionais, vamos dar uma olhada em alguns recursos mais avançados.

Comandos de barra e atalhos de fluxo de trabalho

Os comandos de barra funcionam como atalhos para operações comuns na CLI do Copilot. Eles fazem as coisas acontecerem na hora, sem precisar de instruções completas, o que os torna úteis para tarefas rápidas ou repetitivas. Exemplos comuns incluem:

• /explain para interpretar um comando ou script

• /commit para preparar uma mensagem de commit a partir das alterações preparadas

• /pr escrever uma descrição de solicitação pull

• /fix para identificar problemas no código e sugerir correções

• /review resumir ou revisar as mudanças locais

• /run para criar e executar um comando

Personalização

O Copilot CLI guarda suas configurações num arquivo JSON dentro do diretório padrão do Copilot: ~/.copilot. Esse arquivo inclui seus modelos padrão de IA, configurações de integração do editor e preferências de fluxo de trabalho. 

Você pode editar manualmente para controlar como o Copilot se comporta. Como o arquivo fica no seu diretório pessoal, ele vale para todos os projetos, garantindo que tudo fique consistente. 

A CLI também tem comandos pra ajustar a configuração sem precisar mexer nos arquivos manualmente. Os comandos mais comuns são:

• copilot config view para mostrar suas configurações atuais

• copilot config set para atualizar um valor específico da configuração

• copilot config reset para voltar tudo ao padrão

Em ambientes com vários usuários ou empresariais, as equipes podem distribuir modelos de configuração padrão ou usar scripts de integração para definir comportamentos padrão para cada desenvolvedor. 

Cada usuário ainda mantém seu próprio diretório de configuração, mas os administradores podem combinar padrões compartilhados com personalizações individuais. Esse equilíbrio cria uma experiência consistente do Copilot em toda a organização, ao mesmo tempo em que mantém a flexibilidade que os desenvolvedores precisam.

Configurações de segurança

Para dados sensíveis, como tokens ou identificadores específicos da empresa, a CLI do Copilot usa variáveis de ambiente. Você pode adicionar essas variáveis ao seu perfil do shell, carregá-las de um gerenciador de segredos ou defini-las por sessão para autenticação de curta duração. Isso mantém os segredos fora do controle de versão e reduz os riscos de segurança.

Casos de uso da CLI do GitHub Copilot

Essa seção mostra como a CLI pode melhorar a produtividade em tarefas comuns de desenvolvimento.

Começando com instruções simples

Comece com comandos simples para se familiarizar com a CLI do Copilot. Embora o agente seja poderoso, a qualidade do resultado depende da sua contribuição. Para dominar a arte de escrever instruções eficazes, confira nosso Entendendo a Engenharia de Prompts.

Você pode usá-lo para explicar comandos do shell, resumir erros ou gerar pequenos trechos de código. Por exemplo, a gente poderia pedir pra ele limpar imagens e contêineres Docker que não estão sendo usados:

copilot -p "Clean up unused Docker images and containers"

Como mostra a imagem, um script completo é gerado e, quando você aceita a sugestão, ele é executado e remove as imagens e contêineres não utilizados, exatamente como queríamos.

Criação de documentação

Você pode pedir ao Copilot para criar documentação, adicionar comentários embutidos ou atualizar documentos já existentes. Vamos ver como ele pode criar um arquivo README para um repositório:

copilot -p "Generate a README for this repo: include purpose, install, basic usage, and example commands."

Como eu já tinha um arquivo README, o Copilot atualizou ele pra ficar de acordo com os novos requisitos que eu dei no prompt. O diff mostra o texto removido em vermelho e o texto adicionado em verde, facilitando a revisão e aprovação das alterações.

Atualizações de estrutura e modernização de código legado

Em bases de código antigas, os desenvolvedores usam a CLI do Copilot para trocar APIs que não são mais usadas, migrar padrões antigos ou refatorar projetos inteiros. Você também pode pedir ao Copilot para atualizar bibliotecas desatualizadas, reescrever código para novas APIs ou preparar notas de migração para versões principais. 

Por exemplo, eu pedi pra ele atualizar todas as dependências do Gradle pra suas versões seguras mais recentes:

copilot -p "Upgrade all Gradle dependencies to their latest safe versions"

Encontramos duas dependências com atualizações relevantes e podemos simplesmente aceitar a diferença para incluir essas versões mais recentes.

Conclusão

O GitHub Copilot CLI transforma o terminal de um prompt de comando estático em um agente inteligente capaz de entender e executar fluxos de trabalho de desenvolvimento complexos. Ao juntar o contexto profundo do repositório com o planejamento autônomo, isso permite que os desenvolvedores automatizem tarefas chatas e gerenciem todo o ciclo de vida do GitHub sem precisar sair da linha de comando.

A CLI do Copilot vai continuar evoluindo com integrações mais profundas do servidor MCP e uma automação mais confiável, controlada por agentes. O futuro da IA agênica também está caminhando para a integração de modelos de visão. Isso vai permitir que ferramentas de IA, como o Copilot, interpretem capturas de tela de bugs ou modelos de design e ofereçam suporte a fluxos de trabalho mais autônomos diretamente a partir de informações visuais.

Para uma implementação organizacional tranquila, comece com um guia de integração compartilhado que abranja a instalação e a autenticação. Mantenha a consistência usando modelos de configuração baseados em JSON e variáveis de ambiente seguras. Para ambientes maiores, ofereça perfis de configuração específicos para funções ou equipes para manter a consistência.

Se você quer dominar os fluxos de trabalho agênicos e explorar todo o potencial do desenvolvimento assistido por IA, continue aprendendo com nosso IA para Engenharia de Software programa