Copilot CLI e SDK: Programação orientada a agentes no ecossistema .NET
O Copilot CLI e SDK formam a dupla do GitHub que leva a programação orientada a agentes para o terminal e para dentro das aplicações .NET. Durante décadas, o desenvolvimento de software foi definido por uma habilidade humana distinta: transformar problemas abstratos em código funcional.
Essa característica, que por muito tempo nos colocou em uma posição única, passa agora por uma mudança estrutural profunda. Afinal, agentes de programação baseados em inteligência artificial já raciocinam, exploram bases de código e executam tarefas complexas de forma autônoma.
Neste artigo, apresento uma análise técnica e reflexiva sobre o GitHub Copilot CLI e o Copilot SDK para .NET, com base em uma apresentação recente da comunidade .NET AI. O objetivo não é apenas mostrar funcionalidades, mas contextualizar o impacto dessas ferramentas na prática profissional.
Do autocomplete ao Copilot CLI e SDK
A primeira geração de ferramentas de IA para desenvolvimento concentrou-se em autocompletar código e sugerir trechos com base no contexto. Embora úteis, essas abordagens mantinham o desenvolvedor como executor central de todas as etapas.
Com a evolução recente, surgiram os agentes de programação. São sistemas que interpretam objetivos de alto nível, exploram bases de código, executam comandos, validam resultados e iteram sobre as soluções.
Ferramentas como o Copilot CLI e o modo agente do GitHub Copilot introduzem um fluxo em que o desenvolvedor atua mais como arquiteto e revisor. Em outras palavras, ele deixa de ser um digitador de código.
Essa transição altera bastante a dinâmica do trabalho técnico. Assim, a pergunta deixa de ser "como escrever este código?" e passa a ser "como especificar corretamente o problema e validar a solução produzida?".
Se o conceito de agente ainda for novo para você, o artigo o que são agents explica a base antes de seguir.
O que é o Copilot CLI e SDK
O GitHub Copilot CLI é um agente de programação que roda direto no terminal. Já o Copilot SDK é uma biblioteca que expõe o mesmo motor do Copilot CLI como um runtime programável para aplicações e serviços.
Na prática, o Copilot CLI e SDK compartilham a mesma base. O CLI é a interface interativa para o desenvolvedor, enquanto o SDK permite que você embuta esse agente no seu próprio código.
Segundo o repositório oficial do Copilot SDK, a biblioteca tem versões para Node.js, Python, Go, .NET, Java e Rust. Além disso, o SDK está disponível de forma geral e segue versionamento semântico.
Ambos exigem uma assinatura do GitHub Copilot, inclusive o plano gratuito com uso limitado. Como alternativa, o SDK aceita BYOK, ou seja, chaves próprias de provedores como OpenAI, Azure AI Foundry e Anthropic.
O Copilot CLI como ambiente de trabalho autônomo
O Copilot CLI representa uma ruptura em relação aos ambientes tradicionais de desenvolvimento. Diferentemente de uma IDE, ele não depende de interface gráfica nem de uma linguagem específica.
Executado direto no terminal, o agente pode ser chamado em qualquer diretório. A partir daí, ele explora arquivos, roda comandos, cria branches, executa testes e abre pull requests.
Instalação do Copilot CLI
A documentação do GitHub oferece algumas formas de instalação. Pelo npm, que exige Node.js 22 ou superior, o comando funciona em qualquer sistema:
# Instalação via npm (todas as plataformas)
npm install -g @github/copilot
# Windows, via WinGet
winget install GitHub.Copilot
# macOS e Linux, via Homebrew
brew install --cask copilot-cli
Depois, basta rodar copilot na pasta do projeto. No primeiro acesso, o CLI pede o login com o comando /login.
Velocidade na execução de tarefas
Um aspecto relevante é a velocidade com que tarefas completas ficam prontas. Na apresentação, a implementação de uma funcionalidade simples, como a adição de um comando ao próprio Copilot CLI, levou poucos segundos.
O agente identifica padrões no código, localiza pontos de extensão, aplica alterações, executa builds e valida o resultado sem intervenção manual. Contudo, esse nível de automação não elimina a necessidade de entendimento técnico.
Na verdade, ele desloca o esforço para atividades de maior valor. Definir requisitos, analisar impacto e revisar criticamente o que o agente produziu passam a ocupar o centro do trabalho.
Para ir além do básico, o artigo sobre GitHub Copilot CLI com MCP e automação no terminal mostra como conectar servidores MCP ao agente.
Prototipagem rápida e mudança no processo de design
Um dos efeitos mais imediatos da adoção de agentes é a transformação do processo de design de software. Tradicionalmente, decisões arquiteturais exigiam longas discussões prévias, porque o custo de implementação era alto.
Com agentes capazes de produzir protótipos funcionais em minutos, torna-se viável experimentar várias abordagens. Então, você as avalia na prática e descarta as que não se mostram adequadas.
Esse modelo favorece um ciclo de aprendizado contínuo. Dessa forma, a implementação deixa de ser um compromisso irreversível e vira uma ferramenta de exploração.
O código que o agente produz pode ser visto como um rascunho técnico. Por isso, você o refina ou descarta conforme a necessidade, sem o peso emocional de ter digitado tudo à mão.
No ecossistema .NET, o Copilot CLI e SDK tornam esse ciclo ainda mais curto. Você testa uma ideia no terminal e, se ela funcionar, pode automatizar o mesmo fluxo em uma aplicação com o SDK.
Planejamento explícito com Plan Mode no Copilot CLI
Um desafio recorrente no uso de agentes é a subespecificação de tarefas. Diante de uma instrução vaga, o agente tende a fazer apenas o mínimo necessário, e o resultado fica incompleto ou desalinhado das expectativas.
Para mitigar esse problema, o Copilot CLI oferece o Plan Mode. Nesse modo, o agente não escreve código de imediato.
Para ativá-lo, pressione Shift+Tab para alternar entre o modo normal e o modo de plano, ou use o comando /plan. Segundo a documentação, o Copilot faz perguntas de esclarecimento e aguarda a sua aprovação antes de implementar.
Em vez de sair codando, o agente monta um plano detalhado em Markdown. Esse plano descreve fases, impactos no código, alterações em banco de dados, estratégias de validação e critérios de aceitação.
Você pode revisar, ajustar e enriquecer esse plano antes do início da implementação. Com isso, a colaboração fica mais estruturada, e o agente atua como assistente de design técnico, e não como executor cego de comandos.
Subagentes e revisões em paralelo
Outra capacidade relevante apresentada é o uso de subagentes. Eles permitem executar tarefas em paralelo, inclusive com modelos de linguagem diferentes.
No Copilot CLI, o comando /fleet quebra uma tarefa em subtarefas paralelas executadas por subagentes. Além disso, o comando /model troca o modelo no meio da sessão, conforme a complexidade do trabalho.
Um exemplo prático é a revisão de pull requests complexos. Nesse cenário, vários agentes analisam o mesmo conjunto de alterações de forma independente.
Comparar os resultados reduz o risco de erros e alucinações, por exemplo entre um modelo mais conservador e outro mais crítico. Assim, as divergências entre as análises viram sinais valiosos para uma investigação adicional.
Como o Copilot CLI e SDK compartilham o mesmo motor, você também pode montar essa revisão em paralelo por código. Basta abrir várias sessões no SDK, cada uma com um modelo diferente, e comparar as respostas.
O comando /review complementa esse fluxo. Com ele, você pede ao agente que revise as mudanças do branch atual em relação ao main, com foco em bugs e problemas de segurança.
Skills no Copilot CLI e SDK
O conceito de skills adiciona mais uma camada de eficiência. Skills são pastas com instruções, scripts e recursos que o Copilot carrega quando são relevantes para uma tarefa específica.
Diferentemente de prompts extensos, apenas um resumo da skill fica no contexto ativo. Por isso, você evita desperdício de tokens e a queda de desempenho que um contexto inchado provoca.
Essas skills podem incluir desde scripts utilitários até fluxos completos de automação. Geração de documentos, interação com APIs e testes ponta a ponta são exemplos comuns.
Além disso, elas podem ser versionadas, compartilhadas em repositórios e reutilizadas por equipes inteiras. Segundo a documentação do GitHub, as skills de projeto ficam em .github/skills, .claude/skills ou .agents/skills, enquanto as pessoais ficam em ~/.copilot/skills.
O formato segue um padrão aberto e funciona no Copilot CLI, no agente de nuvem, no code review e no modo agente do VS Code. Para entender quando usar skills e quando criar agentes, leia o comparativo agents ou skills: qual escolher.
Feedback automatizado no Copilot CLI e SDK
Agentes ficam bem mais eficazes quando recebem feedback direto. A integração com compiladores, test runners e até navegadores automatizados, como no uso do Playwright, permite que o próprio agente valide suas alterações.
Nesse modelo, o agente não apenas escreve código. Ele também executa cenários reais de uso, observa falhas, corrige problemas e itera até chegar a um estado funcional.
Essa abordagem reduz bastante o ciclo manual de tentativa e erro. Com isso, o desenvolvimento com o Copilot CLI e SDK se aproxima de um processo verdadeiramente autônomo.
O Copilot CLI também oferece o modo autopilot, em que o agente trabalha sozinho até concluir a tarefa. Já o comando /delegate envia o pedido ao agente de nuvem do Copilot, que abre um pull request com as mudanças.
Mesmo assim, você continua no controle das permissões. O CLI pede aprovação para cada ferramenta, e você pode liberar uma ferramenta apenas para a sessão atual.
O Copilot SDK para .NET
Além do uso interativo, o Copilot SDK permite incorporar agentes direto em aplicações .NET. Com ele, você cria sessões de agente por código, envia instruções, recebe eventos e expõe funções .NET como ferramentas que o agente pode chamar.
A instalação é feita pelo NuGet. O pacote baixa automaticamente o runtime do Copilot CLI correspondente à plataforma, então não é preciso instalar o CLI separadamente:
dotnet add package GitHub.Copilot.SDK
Criando uma sessão de agente em C#
O exemplo abaixo, baseado no README oficial, cria um cliente, abre uma sessão e espera a resposta do agente:
using GitHub.Copilot;
// Cria e inicia o cliente, que sobe o runtime do Copilot
await using var client = new CopilotClient();
await client.StartAsync();
await using var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "gpt-5",
// Aprova todas as ferramentas; use com cuidado fora de testes
OnPermissionRequest = PermissionHandler.ApproveAll,
});
var done = new TaskCompletionSource();
session.On<SessionEvent>(evt =>
{
if (evt is AssistantMessageEvent message)
{
Console.WriteLine(message.Data.Content);
}
else if (evt is SessionIdleEvent)
{
// A sessão fica ociosa quando o agente termina o trabalho
done.SetResult();
}
});
await session.SendAsync(new MessageOptions { Prompt = "Summarize the open issues in this repository." });
await done.Task;
Repare que a comunicação acontece por eventos. Dessa forma, a sua aplicação acompanha cada mensagem, chamada de ferramenta e mudança de estado do agente.
Expondo funções .NET como ferramentas
O ponto mais interessante do SDK é deixar o agente chamar código que você controla. Para isso, use CopilotTool.DefineTool, que se apoia no Microsoft.Extensions.AI:
using System.ComponentModel;
using Microsoft.Extensions.AI;
var session = await client.CreateSessionAsync(new SessionConfig
{
Model = "gpt-5",
Tools =
[
CopilotTool.DefineTool(
async ([Description("Issue identifier")] string id) =>
{
// Busca a issue no seu sistema de tickets
var issue = await FetchIssueAsync(id);
return issue;
},
factoryOptions: new AIFunctionFactoryOptions
{
Name = "lookup_issue",
Description = "Fetch issue details from our tracker",
}),
],
});
Com uma ferramenta assim, o agente consegue estimar o esforço de uma issue, por exemplo. Ele lê os detalhes, explora o repositório e devolve uma estimativa fundamentada.
Cenários de uso do Copilot CLI e SDK
O SDK possibilita cenários avançados, como estimativa automática de esforço para issues, análise de repositórios e geração de documentação técnica. Também serve para orquestrar fluxos complexos dentro de serviços internos.
Diferentemente de abordagens de baixo nível baseadas apenas em chat completions, o SDK entrega um agente completo. Ou seja, você herda todo o conjunto de heurísticas e ferramentas que o GitHub desenvolveu para o Copilot.
Por exemplo, o SDK aceita servidores MCP, agentes customizados e compactação automática de contexto em sessões longas. Portanto, o Copilot CLI e SDK compartilham tanto o motor quanto o ecossistema de extensões.
Quando usar o Copilot CLI e quando usar o SDK
A escolha entre o Copilot CLI e SDK depende de quem conduz o trabalho. Quando um desenvolvedor está no comando, explorando código e revisando cada passo, o CLI é a escolha natural.
Por outro lado, quando a tarefa precisa rodar sem uma pessoa no terminal, o SDK faz mais sentido. Um serviço que analisa cada issue nova, por exemplo, ou um pipeline que gera documentação a cada release.
Também vale considerar o controle de permissões. No CLI, você aprova as ferramentas de forma interativa, enquanto no SDK a sua aplicação decide por meio do OnPermissionRequest.
Em resumo, comece pelo CLI para entender o comportamento do agente no seu repositório. Depois, leve para o SDK apenas os fluxos repetitivos que já provaram valor.
Assista à apresentação
A análise deste artigo se baseia na apresentação da comunidade .NET AI sobre o Copilot CLI e SDK. Vale assistir para ver as demonstrações ao vivo:
Considerações finais sobre o Copilot CLI e SDK
A ascensão dos agentes de programação representa uma mudança estrutural na engenharia de software. Nesse cenário, o Copilot CLI e SDK não substituem o desenvolvedor, mas redefinem o seu papel.
A escrita de código torna-se uma atividade delegável. No entanto, a responsabilidade pela especificação correta, pela validação e pela integração das soluções continua humana.
Adotar essas ferramentas exige uma mudança de mentalidade. Mais do que aprender comandos novos, é preciso formular problemas com clareza, definir critérios objetivos de sucesso e confiar em ciclos rápidos de experimentação.
Estamos, sem dúvida, diante de um dos momentos mais transformadores da história do desenvolvimento de software. Por isso, compreender e dominar esses instrumentos deixou de ser apenas vantagem competitiva e virou passo essencial para continuar relevante.
FAQ
Qual a diferença entre o Copilot CLI e o Copilot SDK?
O Copilot CLI é o agente interativo que roda no terminal. O Copilot SDK expõe o mesmo motor como biblioteca, para você embutir o agente em aplicações e serviços.
Preciso instalar o Copilot CLI para usar o SDK no .NET?
Não. O pacote GitHub.Copilot.SDK baixa automaticamente o runtime do CLI para a plataforma do build.
Como ativar o Plan Mode no Copilot CLI?
Pressione Shift+Tab para alternar para o modo de plano ou use o comando /plan. O agente então cria um plano e espera a sua aprovação antes de implementar.
Onde ficam as skills do Copilot?
As skills de projeto ficam em .github/skills, .claude/skills ou .agents/skills. As skills pessoais ficam em ~/.copilot/skills.
O Copilot SDK exige assinatura do GitHub Copilot?
Exige uma assinatura, inclusive o plano gratuito com limites. Como alternativa, você pode configurar BYOK com a chave de um provedor de modelos compatível.