Comparando os recursos de personalização do GitHub Copilot na CLI

Introdução

          CLI do Copilot é um agente de IA baseado em terminal que pode responder perguntas, planejar o trabalho e concluir tarefas em seu nome. Ele foi projetado para ser altamente extensível e há várias maneiras pelas quais você pode personalizar seu comportamento e estender suas funcionalidades.

Este artigo explica a diferença entre:

•         **Instruções personalizadas**
  

  Estes dizem Copilotcomo se comportar em geral. Por exemplo, para garantir que qualquer código que Copilot grava esteja em conformidade com seus padrões de codificação. Saiba mais.

•         **Habilidades**
  

  Elas dizem Copilotcomo lidar com um tipo específico de tarefa. Por exemplo, para usar uma ferramenta específica ao trabalhar em um tipo específico de tarefa. Saiba mais.

•         **Ferramentas**
  
  
          **Elas fornecem habilidades**. Por exemplo, para localizar e modificar arquivos ou para interagir com partes de GitHub. 
          [Saiba mais](#tools).
  

•         **Servidores MCP**
  
  
          **Elas adicionam coleções de ferramentas** que permitem Copilot interagir com serviços externos. 
          [Saiba mais](#mcp-servers).
  

•         **Ganchos**
  

  Elas permitem que você execute sua própria lógica em momentos específicos do ciclo de vida. Por exemplo, você pode executar um script específico sempre que uma sessão da CLI for iniciada ou encerrada. Saiba mais.

•         **Subagentes**
  

  São processos delegados de agente, vinculados ao agente principal e usados para executar tarefas específicas separadamente do processo do agente principal. Eles têm sua própria janela de contexto, que pode ser preenchida sem afetar o contexto do agente principal. Saiba mais.

•         **Agentes personalizados**
  

  Estas são definições de habilidades especializadas, projetadas para executar tarefas específicas. O agente principal da CLI pode delegar uma tarefa a um subagente, usando um perfil de agente personalizado, para aplicar conhecimento especializado e uma abordagem específica à tarefa. Por exemplo, um agente personalizado pode executar a função de um revisor react, um gravador de documentos, um auditor de segurança ou um gerador de teste. Saiba mais.

•         **Plug-ins**
  

  Esses são pacotes que podem fornecer personalizações pré-configuradas, como habilidades, ganchos, agentes personalizados e servidores MCP. Saiba mais.

Instruções personalizadas

O que são instruções personalizadas?

          **Instruções personalizadas** são diretrizes persistentes que são carregadas de arquivos de instrução no início de uma sessão.

          Copilot localizará e carregará arquivos de instrução de vários locais padrão no repositório, como `AGENTS.md` e `.github/copilot-instructions.md`ou em seu diretório inicial em `$HOME/.copilot/copilot-instructions.md`.

Você pode usar o --no-custom-instructions sinalizador para evitar o carregamento dessas instruções.

Que problema as instruções personalizadas resolvem?

Instruções personalizadas ajudam você a:

• Mantenha-o Copilot alinhado com suas convenções e preferências de codificação.
• Aplique padrões de equipe ou organização de forma consistente.
• Evite ter que incluir lembretes repetitivos em Copilot cada prompt.

Quando você deve usar instruções personalizadas?

Use instruções personalizadas para:

• Regras de estilo e qualidade

  Exemplo: "Prefira PRs pequenos, escreva testes e evite alterar APIs públicas sem discussão.".

• Convenções de repositório

  Exemplo: "Use pnpm, manter entradas de log de alterações em CHANGELOG.md, executar pnpm test antes de confirmar".

• Preferências de comunicação

  Exemplo: "Explicar as compensações brevemente e, em seguida, fornecer a opção recomendada."

Quando você não deve usar instruções personalizadas?

Evite ou mantenha-os mínimos quando:

• Você só deseja o comportamento em um fluxo de trabalho (use uma habilidade em vez disso).
• Suas instruções são tão grandes/específicas que distraem Copilot da tarefa imediata (prefira uma habilidade ou agente personalizado).

Saiba mais sobre instruções personalizadas

Confira Adicionando instruções personalizadas para CLI do GitHub Copilot.

Habilidades

O que é uma habilidade?

Uma habilidade é, minimamente, um arquivo Markdown que contém instruções que Copilot podem ser usadas para executar tarefas em um contexto específico. O nome e a descrição da habilidade permitem Copilot determinar se ele deve usar a habilidade para uma determinada tarefa. Se decidir usar a habilidade, ela carregará as instruções e as seguirá para concluir a tarefa.

As habilidades podem, opcionalmente, referenciar outros arquivos, armazenados no diretório de habilidades. Isso pode incluir scripts que possam ser executados quando a habilidade é utilizada.

Que problema uma habilidade resolve?

As habilidades ajudam você a:

• Padronizar como Copilot executa tarefas em um contexto específico (por exemplo, ao executar uma revisão de código).
• Forneça instruções "just-in-time" sem alterar permanentemente o comportamento de Copilot.
• Evite sobrecarregar Copilota janela de contexto com instruções que não são relevantes para a tarefa atual.

Como você acessa as habilidades?

Você pode invocar manualmente uma habilidade usando um comando de barra. Por exemplo, /Markdown-Checker check README.md. Use /skills list para listar as habilidades disponíveis.

          CLI do Copilot invoca automaticamente as habilidades quando detecta uma relevante para a tarefa atual.

Quando você deve usar uma habilidade?

Use uma habilidade quando desejar:

• Um conjunto repetível de instruções ou funcionalidades para estar disponível para um tipo de tarefa.

  Exemplo: uma habilidade de documentação que verifica se a documentação voltada para o usuário é atualizada quando o código de front-end é alterado.

• Um formato de saída consistente.

  Exemplo: uma habilidade de "rascunho de nota de versão" que garante Copilot o uso de um modelo para criar uma nota de versão.

• Um fluxo de trabalho que às vezes você precisa, mas nem sempre.

  Exemplo: uma habilidade de "refatoração profunda" que você habilita somente durante as migrações.

Quando você não deve usar uma habilidade?

Evite habilidades quando:

• As diretrizes devem ser aplicadas a tudo o que você faz (em vez disso, use instruções personalizadas ).
• Você precisa de novos recursos (talvez seja necessário um servidor MCP para adicionar ferramentas ou um agente personalizado para especialização).

Saiba mais sobre as habilidades do agente

Confira Sobre as habilidades do agente.

Ferramentas

O que é uma ferramenta?

Uma ferramenta é uma capacidade que Copilot usa para fazer algo, como pesquisar arquivos, exibir conteúdo de arquivo, editar, executar uma tarefa ou invocar uma habilidade. Algumas ferramentas são internas e outras podem ser adicionadas por meio de servidores MCP.

Que problema as ferramentas resolvem?

As ferramentas permitem que a CLI:

• Coletar contexto preciso (usando ferramentas de leitura/pesquisa).
• Faça alterações com segurança (usando ferramentas de edição).
• Execute comandos e valide os resultados (potencialmente usando subagentes).

Quando você deve usar ferramentas?

Normalmente, você não chama ferramentas diretamente,Copilot decide usar as ferramentas conforme necessário. Você pode permitir ou negar o uso de ferramentas, seja para uma tarefa específica, para a sessão atual ou para todas as suas CLI do Copilot sessões.

Você verá Copilot ferramentas sendo usadas quando:

• Peça Copilot para pesquisar algo no repositório, atualizar um arquivo ou executar testes.
• Invoque uma habilidade que dispara a skill ferramenta.
• Peça Copilot para executar uma tarefa que exige que ela use uma ferramenta fornecida por um servidor MCP.
• Tarefa Copilot para concluir uma tarefa complexa decide delegar a um subagente, o que aciona a ferramenta task.

Saiba mais sobre como permitir ou negar ferramentas

Confira Sobre GitHub Copilot CLI.

Servidores MCP

O que é um servidor MCP?

Um servidor MCP é um serviço que permite que aplicativos de IA, como CLI do Copilot, conectem-se a fontes de dados e ferramentas externas.

Adicionar um servidor MCP para CLI do Copilot fornecer recursos adicionais, permitindo que você use ferramentas fornecidas por esse servidor MCP. Por exemplo, você pode adicionar um servidor MCP que fornece ferramentas para interagir com um aplicativo de calendário online ou um sistema de tíquetes de suporte.

Que problema os servidores MCP resolvem?

Os servidores MCP ajudam quando as ferramentas internas não são suficientes. Eles podem:

• Conectar CLI do Copilot a sistemas externos.
• Adicione ferramentas criadas com finalidade (por exemplo, para trabalhar com APIs, bancos de dados ou geração de imagem).
• Padronizar padrões de acesso seguro para recursos não repositórios.

Quando você deve usar um servidor MCP?

Use um servidor MCP quando precisar:

• Integração com dados ou sistemas externos.

  Exemplo: How many support tickets have been opened this month for Product X?

• Ações específicas do domínio que você deseja que a CLI execute em seu nome.

  Exemplo: Message the bug-watch channel: Only 2 support tickets raised this month for Product X.

Quando você não deve usar um servidor MCP?

Evite adicionar servidores MCP quando:

• As ferramentas integradas já abrangem suas necessidades.

Saiba mais sobre servidores MCP

Confira Sobre o Protocolo de Contexto de Modelo (MCP).

Ganchos

O que é um gancho?

          **Os ganchos** permitem que você especifique que, em um determinado ponto em um ciclo de vida de sessão, CLI do Copilot executará um comando de shell definido.

Gancho	Quando executa
preToolUse / postToolUse	Antes/depois de uma ferramenta ser executada.
userPromptSubmitted	Quando um usuário envia um prompt.
sessionStart / sessionEnd	No início/final de uma sessão.
errorOccurred	Quando ocorre um erro.
agentStop	Quando o agente principal para sem um erro.
subagentStop	Quando um subagente se completa.

Que problema os ganchos resolvem?

Os ganchos ajudam quando você deseja controle programável ou observabilidade em torno do CLI do Copilot comportamento, como:

•         **Aplicar proteções:** bloquear ou avisar antes que determinadas ferramentas sejam executadas.
  

•         **Adicionando registro/telemetria**
  

•         **Personalizando o comportamento de repetição/anulação em erros recuperáveis**
  

•         **Adicionando verificações de "política",** por exemplo, para impedir edições em caminhos protegidos.
  

•         **Interceptando o momento em que um subagente termina**, antes que os resultados retornem ao agente pai.
  

Ganchos são úteis quando você precisa de mais controle do que habilidades ou instruções personalizadas podem fornecer. Embora as habilidades e instruções orientem o comportamento do Copilot por meio de prompts, os ganchos asseguram que as operações definidas serão realizadas em momentos específicos—for example, para impedir a execução de uma ferramenta ou para registrar a atividade quando uma sessão se encerrar.

Quando você deve usar ganchos?

Use ganchos quando desejar:

•         **Barreiras de ferramentas**
  

  • Exemplo: antes de bash executar, exija que o comando específico corresponda a uma lista de permissões.
  • Exemplo: antes de edit ser executado, bloqueie alterações em infra/ a menos que haja um ID do tíquete presente.

•         **Automação do ciclo de vida da sessão**
  

  • Exemplo: quando o agente parar, arquive a transcrição da sessão em um local de armazenamento.

•         **Política de tratamento de erros**
  

  • Exemplo: em erros de limitação de taxa, escolha automaticamente "repetir" com uma contagem de repetição limitada.

•         **Controle de fluxo de trabalho subagente**
  

  • Exemplo: quando um subagente for concluído, valide sua saída antes de passar os resultados de volta para o agente principal.

Quando você não deve usar ganchos?

Evite ganchos quando:

• Você só precisa de instruções consistentes de solicitação ou fluxo de trabalho (usar habilidades).
• Você deseja preferências e padrões persistentes (use instruções personalizadas).
• Você precisa usar novos recursos externos (servidores MCP e ferramentas).
• Manter a configuração que pode afetar cada sessão pode ser problemático para você.

Saiba mais sobre ganchos

Confira Usando ganchos com CLI do GitHub Copilot.

Subagentes

O que é um subagente?

Um subagente é a execução de um agente de IA separado que o agente principal de uma CLI do Copilot sessão inicia para realizar um trabalho específico.

          CLI do Copilot usa um subagente quando o agente principal decide que delegar uma parte do trabalho a um agente separado é a melhor maneira de concluir a solicitação do usuário.

Que problema os subagentes resolvem?

Os subagentes ajudam Copilot:

• Mantenha focada a janela de contexto do agente principal em uma sessão da CLI, descarregando parte do trabalho para um agente separado.
• Paralelize o trabalho, quando necessário, executando determinadas tarefas em segundo plano.
• Execute um agente personalizado separadamente do agente principal, executando um trabalho especializado com uma abordagem diferente do trabalho realizado pelo agente principal.

Quando os subagentes são usados?

          Copilot é provável que use um subagente para:

• Exploração de base de código

  Por exemplo, listando todos os endpoints em uma API.

• Execução de comando para tarefas complexas

  Por exemplo, executar um conjunto de testes ou criar um projeto grande e analisar os resultados.

• Revisão de alterações

  Por exemplo, examinar as alterações em etapas e identificar possíveis problemas de segurança.

• Trabalho complexo de várias etapas

  Por exemplo, implementar um recurso com várias alterações.

• Para usar agentes personalizados

  Se você definiu um agente personalizado e ele é qualificado para inferência (infer não está definido como false), Copilot pode optar por delegar o trabalho a esse agente personalizado iniciando um subagente com a configuração do agente personalizado.

Agentes personalizados

O que é um agente personalizado?

          **Os agentes personalizados** fornecem Copilot conhecimento especializado sobre um assunto específico e definem uma abordagem específica que Copilot deve ser usada ao trabalhar nessa área. Você pode pensar em um agente personalizado como uma "persona" que Copilot pode adotar ao trabalhar em determinadas tarefas.

          CLI do Copilot tem vários agentes personalizados internos. Por exemplo, os `explore`, `task`, `research`, `code-review` e `general-purpose` agentes. Você também pode definir seus próprios agentes personalizados para atender às suas necessidades específicas.

Você define um agente personalizado em um arquivo Markdown com o frontmatter YAML. O arquivo contém:

• Uma descrição da função e da experiência do agente
• Uma lista de ferramentas permitidas (ou todas as ferramentas)
• Conexões de servidor MCP opcionais
• Uma configuração opcional infer — ao ser habilitada, Copilot delegará automaticamente para esse agente quando detectar uma tarefa que corresponda à especialidade do agente.

Que problema os agentes personalizados resolvem?

Os agentes personalizados ajudam quando você precisa:

• Conhecimento especializado a ser aplicado consistentemente em um contexto específico.
• Permissões de ferramenta diferentes para um trabalho diferente, conforme definido na configuração do agente personalizado.
• Para permitir que a janela de contexto do agente principal permaneça focada na tarefa principal, com a janela de contexto do próprio agente personalizado sendo usada para o trabalho especializado que ele executa.

Quando você deve usar um agente personalizado?

Use um agente personalizado quando desejar:

• Um revisor especializado ou auxiliar

  Exemplo: crie um agente personalizado "react-reviewer" que se concentre no trabalho envolvendo padrões React.

• Permissões mais seguras

  Exemplo: um agente personalizado que pode apenas view/grep/glob (leitura única) para auditoria.

• Delegação automática opcional

  Exemplo: defina infer: true na configuração do agente personalizado para que Copilot possa usar automaticamente esse agente personalizado quando apropriado.

Quando você não deve usar um agente personalizado?

Evite agentes personalizados quando:

• Você só precisa de texto de orientação (uma habilidade pode ser uma solução mais leve).
• Você não precisa de especialização e o agente padrão executa bem as tarefas.

Saiba mais sobre agentes personalizados

Confira Configuração de agentes personalizados.

Plug-ins

O que é um plug-in?

Um plug-in é um pacote instalável que pode fornecer um pacote de funcionalidade para Copilot. Um plug-in pode incluir qualquer combinação dos outros recursos de personalização. Por exemplo, habilidades, agentes personalizados, ganchos e configurações de servidor MCP.

          Copilot inclui comandos de gerenciamento de plug-in (instalar, atualizar, listar, desinstalar) e dá suporte à instalação de um marketplace ou diretamente de um repositório GitHub.

Que problema os plug-ins resolvem?

Os plug-ins ajudam você:

• Adicione facilmente um pacote de funcionalidade a Copilot sem precisar configurar manualmente cada peça.
• Empacote e distribua uma configuração personalizada, potencialmente uma combinação de habilidades, agentes personalizados, ganchos e servidores MCP, para sua equipe ou para o público.
• Altere a funcionalidade disponível sem precisar copiar manualmente arquivos em diretórios.

Quando você deve usar um plug-in?

Use um plug-in quando:

• Você quer um pacote para toda a equipe

  Exemplo: um plugin de engenharia para toda a empresa que inclui:

  • Habilidades para resposta a incidentes.
  • Um agente personalizado para revisão de código.
  • Um servidor MCP para serviços internos.

• Você deseja facilitar a instalação e as atualizações

  Exemplo: instale um plug-in inicialmente e atualize-o regularmente usando /plugin update PLUGIN-NAME.

Quando você não deve usar um plug-in?

Evite plug-ins quando:

• Você está experimentando localmente e não precisa de distribuição (use habilidades locais, instruções personalizadas ou agentes personalizados).
• Você só precisa de um pequeno fluxo de trabalho único. Um único arquivo de habilidade pode ser mais simples.

Juntando tudo: escolhendo a melhor opção

Requirement	Melhor opção
Quero que Copilot sempre siga nossas convenções de repositório.

          **Instruções personalizadas** |

| Quero um fluxo de trabalho repetível que possa invocar sob demanda. | Habilidades | | Quero Copilot responder perguntas e realizar trabalhos no meu repositório. | Copilot solicita permissão para usar as ferramentas apropriadas | | Quero diretrizes, políticas ou automação no uso de ferramentas e eventos de sessão. | Ganchos | | Preciso Copilot ser capaz de usar as ferramentas fornecidas por um serviço externo. | Servidores MCP | | Ao trabalhar em tarefas específicas, quero Copilot operar como especialista com um conjunto de ferramentas restrito. | Agente personalizado | | Quero que Copilot execute uma tarefa complexa em meu nome. | Copilot usa automaticamente subagentes quando apropriado. | | Quero adicionar um pacote de funcionalidade a CLI do Copilot sem configurá-lo manualmente. | Plug-in |

Leitura adicional

•         [AUTOTITLE](/copilot/how-tos/copilot-cli)