Introdução

O GitHub Copilot no Visual Studio 2022 deixou de ser apenas um autocomplete inteligente. Em 2026, ele já atua como assistente de desenvolvimento dentro da IDE: sugere código, explica trechos complexos, ajuda a escrever testes, apoia investigação de bugs, gera documentação, cria diagramas em Markdown/Mermaid e, nas versões mais recentes, entra em fluxos mais agênticos com Agent Mode e MCP servers.

Mas existe uma diferença enorme entre “usar Copilot” e trabalhar bem com Copilot.

Quem usa o Copilot como se fosse apenas um botão mágico normalmente recebe respostas genéricas. Quem aprende a fornecer contexto, criar prompts reutilizáveis, registrar padrões do projeto e revisar a saída como engenheiro consegue transformar a ferramenta em uma espécie de par técnico disciplinado.

Este artigo é um guia prático para usar o GitHub Copilot no Visual Studio 2022, com foco em:

  • Configuração e versões importantes.
  • Quando usar autocomplete, chat, inline chat, Agent Mode e MCP.
  • Dicas de prompting para código real.
  • Exemplos de prompts para C#, .NET, APIs, testes, SQL, documentação e D365 F&O.
  • Como criar algo semelhante a um skill, usando copilot-instructions.md, arquivos .instructions.md, prompt files e, onde disponível, SKILL.md.
  • Boas práticas de segurança, revisão e adoção em equipe.

Antes de Começar: Versões e Recursos

O primeiro cuidado é entender que os recursos do Copilot evoluem rápido. Em maio de 2026, a documentação oficial da Microsoft indica os seguintes marcos para Visual Studio:

Recurso Versão mínima indicada
Uso básico do Copilot no Visual Studio Visual Studio 2022 17.8 ou superior
Experiência unificada do Copilot Chat Visual Studio 2022 17.10 ou superior
Prompt library, experiência guiada e preview de Markdown Visual Studio 2022 17.12 ou superior
Agent Mode, MCP, anexos de imagem no chat, NES e recursos mais recentes Visual Studio 2022 17.14 ou superior

Minha recomendação prática: se você quer usar Copilot de forma séria no VS2022, atualize para a versão mais recente disponível do Visual Studio 2022. Grande parte das dicas deste artigo funciona em versões anteriores, mas os recursos mais interessantes de contexto, agente e customização dependem das versões novas.

Também vale observar uma nuance importante: a documentação de Agent Skills está em transição entre produtos e versões. A Microsoft já documenta skills para GitHub Copilot em experiências mais novas, enquanto a documentação do GitHub menciona suporte em Copilot cloud agent, Copilot CLI e agent mode no Visual Studio Code. Para Visual Studio 2022, a abordagem mais confiável hoje é criar “skills práticos” com:

  • .github/copilot-instructions.md
  • .github/instructions/*.instructions.md
  • .github/prompts/*.prompt.md
  • Documentos de referência no repositório
  • MCP servers quando fizer sentido

Se o seu ambiente já expõe suporte a skills no formato SKILL.md, você pode usar a estrutura deste artigo. Se ainda não expõe, a mesma ideia funciona como biblioteca de prompts e instruções reutilizáveis.

O Modelo Mental Correto

O Copilot não substitui o desenvolvedor. Ele acelera leitura, escrita, refatoração e investigação. A responsabilidade técnica continua sua.

Pense nele em cinco papéis:

  1. Autocomplete contextual: bom para completar trechos, padrões repetitivos e código próximo ao que você já escreveu.
  2. Par de programação: bom para discutir abordagens, alternativas e trade-offs.
  3. Revisor inicial: bom para procurar inconsistências, edge cases e ausência de testes.
  4. Documentador: bom para explicar métodos, criar READMEs, gerar XML docs e diagramas.
  5. Executor assistido: em Agent Mode, pode planejar, editar múltiplos arquivos, rodar comandos e iterar, mas sempre com revisão humana.

A regra simples: quanto maior o impacto da mudança, mais contexto, restrições e verificação você precisa fornecer.

Quando Usar Cada Recurso

1. Inline Completions

Use quando você já sabe o que quer escrever e quer acelerar a digitação.

Bons cenários:

  • Completar propriedades, DTOs, mapeamentos e métodos pequenos.
  • Criar código repetitivo.
  • Gerar testes simples a partir de um padrão já existente.
  • Transformar um comentário curto em código.
  • Completar documentação XML em C#.

Exemplo:

// Create a method that validates if a Brazilian CNPJ has 14 digits and only numbers.

Dica: se a sugestão vier grande demais, aceite só o trecho útil. No Visual Studio, você pode aceitar parcialmente uma sugestão, palavra por palavra ou linha por linha, dependendo do atalho configurado.

2. Copilot Chat

Use quando você precisa conversar sobre o código.

Bons cenários:

  • Explicar uma classe que você não conhece.
  • Entender uma exceção.
  • Pedir alternativas de design.
  • Pedir uma lista de riscos antes de mexer.
  • Gerar testes com cenários específicos.
  • Criar documentação técnica.
  • Perguntar sobre uma API ou padrão do .NET.

Exemplo:

Explique esta classe como se eu estivesse entrando no projeto hoje.
Separe em: responsabilidade, dependências, fluxo principal, riscos e pontos de teste.

3. Inline Chat

Use quando a pergunta está ligada diretamente ao arquivo aberto ou ao trecho selecionado.

Bons cenários:

  • Refatorar uma função específica.
  • Corrigir uma expressão.
  • Adicionar validação em um método.
  • Melhorar nomes.
  • Extrair método.
  • Adicionar tratamento de erro local.

Exemplo:

Refatore este método para reduzir duplicação, mantendo a assinatura pública e sem alterar o comportamento.
Depois explique os riscos da alteração.

4. Agent Mode

Use para tarefas com mais de um passo, especialmente quando precisa editar múltiplos arquivos.

Bons cenários:

  • Criar testes para uma classe e ajustar mocks.
  • Implementar uma feature pequena ponta a ponta.
  • Atualizar uma API e seus testes.
  • Corrigir um bug com base em falha de build.
  • Rodar comandos de build/teste e iterar.

Exemplo:

Implemente validação para impedir criação de pedido sem cliente.
Antes de editar, identifique os arquivos relevantes.
Depois altere o menor número possível de arquivos, crie ou ajuste testes e rode os testes relacionados.
No final, resuma os arquivos alterados e riscos restantes.

Mesmo em Agent Mode, não trate a saída como final automaticamente. Revise diff por diff.

5. MCP Servers

MCP, ou Model Context Protocol, permite conectar o agente a ferramentas externas de forma padronizada. No Visual Studio, a Microsoft posiciona MCP como extensão do Agent Mode.

Cenários úteis:

  • Consultar issues e pull requests no GitHub.
  • Acessar documentação interna.
  • Consultar APIs internas.
  • Conectar fontes de conhecimento do time.
  • Trazer contexto de ferramentas sem colar manualmente no prompt.

Para times que trabalham com D365 F&O, MCP pode ser especialmente interessante no futuro para conectar documentação de arquitetura, padrões X++, pipelines, backlog e bases de conhecimento de suporte.

A Fórmula de Prompt Que Mais Funciona

Um bom prompt técnico costuma ter seis partes:

  1. Objetivo: o que você quer.
  2. Contexto: onde isso se encaixa.
  3. Restrições: o que não pode mudar.
  4. Padrões esperados: framework, estilo, testes, arquitetura.
  5. Formato de saída: lista, código, plano, tabela, diff.
  6. Critério de pronto: como saber que terminou.

Modelo:

Objetivo: [o que preciso fazer]
Contexto: [classe, projeto, regra de negócio, tecnologia]
Restrições: [não mudar contrato público, não criar nova dependência, manter padrão existente]
Padrões: [xUnit, FluentAssertions, async/await, nullable enabled]
Saída: [plano primeiro, depois código, depois riscos]
Pronto quando: [testes passam, casos X/Y/Z cobertos]

Exemplo aplicado:

Objetivo: criar testes unitários para o serviço selecionado.
Contexto: projeto .NET 8, xUnit, Moq e FluentAssertions.
Restrições: não altere a classe de produção ainda; primeiro apenas sugira os testes.
Padrões: siga o estilo dos testes existentes neste projeto.
Saída: liste os cenários em tabela e depois gere o arquivo de teste.
Pronto quando: cobrir sucesso, entrada inválida, dependência retornando erro e cancelamento.

Dicas Práticas Para Obter Respostas Melhores

1. Abra os arquivos certos antes de perguntar

O Copilot se beneficia do contexto da IDE. Abra a classe principal, os testes existentes, interfaces relacionadas e arquivos de configuração relevantes. Feche arquivos que não têm relação com a tarefa para reduzir ruído.

2. Selecione o trecho antes de pedir alteração

Quando a mudança é local, selecione o método ou classe e use inline chat. Isso reduz a chance de o Copilot sugerir mudanças em lugares errados.

3. Peça plano antes de código

Para mudanças com risco, comece assim:

Antes de escrever código, analise o trecho selecionado e proponha um plano de alteração com riscos.
Não edite nada ainda.

Essa prática evita uma enxurrada de código prematuro.

4. Peça para ele seguir o padrão existente

Prompt simples e poderoso:

Use os padrões já existentes neste projeto. Antes de sugerir código, observe nomes, tratamento de erro, logging, injeção de dependência e estilo dos testes.

5. Dê exemplos de entrada e saída

Copilot responde melhor quando você mostra exemplos.

Entrada: "001234"
Saída esperada: "00001234"
Regra: completar com zeros à esquerda até 8 caracteres.

6. Peça edge cases explicitamente

Liste os edge cases antes de implementar. Depois gere testes para cada edge case.

7. Use persona técnica, mas com cuidado

Funciona bem quando você quer um tipo de revisão:

Atue como um arquiteto .NET sênior revisando código para produção.
Priorize segurança, legibilidade, acoplamento, testes e observabilidade.

Evite exagerar na persona. O que mais melhora a resposta é contexto concreto.

8. Peça alternativas

Mostre três abordagens para resolver isso: simples, extensível e orientada a performance.
Compare trade-offs e recomende uma.

9. Use o Copilot para ler código legado

Explique o fluxo deste método em linguagem de negócio.
Depois identifique regras implícitas, dependências externas e pontos onde uma mudança pode quebrar comportamento.

10. Nunca aceite código que você não consegue explicar

Se a sugestão parece boa, mas você não entende, pergunte:

Explique linha por linha o código sugerido e destaque qualquer suposição feita.

11. Peça testes antes da implementação

Uma técnica forte:

Antes de sugerir a implementação, escreva a lista de testes que provaria que a mudança está correta.

Isso força o raciocínio sobre comportamento.

12. Use o Copilot para melhorar commits e PRs

Com base nas mudanças locais, gere uma mensagem de commit no padrão Conventional Commits.
Depois gere uma descrição de PR com resumo, testes executados e riscos.

13. Use Mermaid para entender arquitetura

O Copilot Chat no Visual Studio consegue gerar Markdown e diagramas Mermaid.

Crie um diagrama Mermaid de sequência para o fluxo desta API, incluindo controller, service, repository e banco.

14. Use imagens quando fizer sentido

Nas versões recentes, o chat aceita anexos de imagem. Isso é útil para:

  • Prints de erro.
  • Layouts de UI.
  • Diagramas de arquitetura.
  • Evidências de comportamento inesperado.

Prompt:

Analise este print do erro e relacione com o código aberto.
Liste hipóteses, como validar cada uma e a correção mais provável.

15. Reinicie a conversa quando o contexto ficou contaminado

Se a conversa ficou longa e o Copilot começou a insistir em uma direção errada, abra uma nova thread. Contexto ruim atrapalha.

Prompts Prontos Para Usar no VS2022

Além de prompts em linguagem natural, o Visual Studio oferece comandos rápidos no Copilot Chat. Eles ajudam a deixar explícita a intenção sem precisar escrever um prompt longo.

Comandos úteis:

Comando Quando usar
/explain Explicar o código selecionado ou um método específico
/fix Propor correção para problema no trecho selecionado
/generate Gerar código a partir de uma solicitação
/doc Criar comentários ou documentação para código
/tests Gerar testes para o código selecionado
/optimize Melhorar performance, confiabilidade, manutenção e arquitetura
/generateInstructions Gerar um copilot-instructions.md inicial para o projeto
/savePrompt Salvar um prompt reutilizável em .github/prompts

Também vale usar as ações de contexto do Visual Studio, como Explain, Generate Tests, Generate Comments, Add to Chat e Optimize Selection. A vantagem dessas ações é que elas já passam o trecho correto como contexto.

Explicar código

Explique o código selecionado em três níveis:
1. Resumo de negócio.
2. Fluxo técnico.
3. Riscos, dependências e pontos de teste.

Revisar método

Revise o método selecionado procurando bugs, problemas de concorrência, null reference, tratamento de erro fraco, baixa legibilidade e ausência de testes.
Mostre achados por severidade e sugira correções pequenas.

Criar testes

Crie testes unitários para a classe selecionada.
Use o framework de testes já existente no projeto.
Cubra caminho feliz, entradas inválidas, exceções de dependências e casos de borda.
Não altere a classe de produção sem pedir.

Refatorar com segurança

Refatore o trecho selecionado para melhorar legibilidade.
Restrições:
- Não alterar assinatura pública.
- Não mudar comportamento.
- Não adicionar dependência externa.
- Manter estilo do projeto.
Depois explique o que mudou e quais testes devem ser executados.

Investigar erro

Tenho este erro: [cole o erro].
Analise com base no arquivo aberto e sugira:
1. Causa mais provável.
2. Como confirmar.
3. Correção mínima.
4. Teste que evita regressão.

Melhorar performance

Analise este trecho como um especialista em performance .NET.
Procure alocações desnecessárias, consultas repetidas, uso indevido de async, loops custosos e problemas de concorrência.
Sugira melhorias por impacto e risco.

Criar documentação

Gere documentação técnica para esta classe em Markdown.
Inclua objetivo, responsabilidades, dependências, exemplos de uso, riscos e pontos de extensão.
Não invente comportamento que não esteja no código.

Preparar PR

Com base nas mudanças locais, gere uma descrição de pull request com:
- Resumo
- Motivação
- Alterações principais
- Como testar
- Riscos
- Checklist de revisão

D365 F&O e X++

Analise este código X++ considerando boas práticas de extensibilidade em Dynamics 365 Finance & Operations.
Procure overlayering, acoplamento desnecessário, nomes pouco claros, risco de performance e ausência de validações.
Sugira melhorias conservadoras e explique o impacto funcional.

SQL e consultas

Revise esta consulta SQL.
Procure risco de SQL injection, índices ausentes, filtros não sargáveis, joins problemáticos e leituras excessivas.
Sugira uma versão mais segura e explique por quê.

Como Criar Algo Semelhante a um Skill

Um “skill” é uma forma de empacotar conhecimento reutilizável. Em vez de escrever o mesmo prompt toda semana, você cria uma instrução estruturada que ensina o assistente a executar uma tarefa do jeito que seu time espera.

No ecossistema Copilot, existem quatro níveis práticos:

  1. Instruções do repositório: regras gerais do projeto.
  2. Instruções específicas por tipo de arquivo: regras para C#, SQL, X++, testes etc.
  3. Prompt files: prompts reutilizáveis que você chama quando precisa.
  4. Agent Skills (SKILL.md): pacotes com instruções, referências, exemplos e scripts, quando o host do Copilot dá suporte.

Para Visual Studio 2022, comece pelos três primeiros. Eles já resolvem grande parte do problema.

Nível 1: .github/copilot-instructions.md

Esse arquivo define instruções gerais do repositório. Ele é ideal para padrões que devem aparecer em quase toda resposta.

Exemplo:

# Copilot Instructions

Este repositório usa .NET 8, C#, nullable reference types e xUnit.

## Padrões gerais

- Siga o estilo dos arquivos existentes antes de sugerir mudanças.
- Prefira mudanças pequenas e fáceis de revisar.
- Não altere contratos públicos sem explicar o impacto.
- Use nomes claros e orientados ao domínio.
- Evite criar abstrações novas sem necessidade real.
- Não introduza dependências externas sem justificativa.

## Testes

- Para novas regras de negócio, sugira testes antes da implementação.
- Use xUnit, Moq e FluentAssertions quando já existirem no projeto.
- Cubra caminho feliz, entradas inválidas, exceções e casos de borda.

## Segurança

- Nunca sugira armazenar segredos em código.
- Use queries parametrizadas.
- Valide entradas externas.
- Explique riscos de segurança quando existirem.

## Dynamics 365 F&O

- Para X++, priorize extensões e evite overlayering.
- Considere performance em consultas e loops.
- Explique impactos funcionais em Finance, SCM ou integrações quando aplicável.

Esse arquivo é a fundação. Ele não substitui bons prompts, mas reduz repetição.

Nível 2: .github/instructions/*.instructions.md

Use quando você quer regras específicas por linguagem, pasta ou tipo de arquivo.

Exemplo para C#:

---
description: Padrões para código C# neste repositório
applyTo: "**/*.cs"
---

- Use async/await sem bloquear threads com `.Result` ou `.Wait()`.
- Propague `CancellationToken` quando o método já recebe um.
- Prefira tipos imutáveis para DTOs quando fizer sentido.
- Valide argumentos públicos.
- Use logging estruturado, sem dados sensíveis.
- Ao criar testes, siga o padrão Arrange/Act/Assert.

Exemplo para SQL:

---
description: Padrões para scripts SQL
applyTo: "**/*.sql"
---

- Use nomes explícitos para tabelas, colunas e aliases.
- Evite `SELECT *`.
- Prefira filtros sargáveis.
- Explique impacto de índices quando sugerir mudanças.
- Nunca concatene entrada de usuário em SQL dinâmico.

Exemplo para X++:

---
description: Padrões para X++ em Dynamics 365 F&O
applyTo: "**/*.xpp"
---

- Priorize extensões e Chain of Command quando aplicável.
- Evite overlayering.
- Explique impactos em performance para consultas, loops e transações.
- Respeite padrões de nomenclatura do projeto.
- Para alterações funcionais, descreva o impacto no processo de negócio.

Nível 3: Prompt Files em .github/prompts

Prompt files são prompts salvos como Markdown, com extensão .prompt.md, geralmente dentro de .github/prompts.

Eles funcionam como “receitas” reutilizáveis.

Exemplo: .github/prompts/create-unit-tests.prompt.md

# Criar testes unitários

Você vai criar testes unitários para o código selecionado ou para a classe informada.

Antes de escrever código:

1. Identifique o comportamento público.
2. Liste dependências externas.
3. Liste cenários de teste em tabela.
4. Confirme o framework de testes usado no projeto.

Ao gerar os testes:

- Siga o estilo dos testes existentes.
- Cubra caminho feliz, entradas inválidas, exceções e casos de borda.
- Use nomes de teste descritivos.
- Não altere código de produção sem pedir.

Saída esperada:

1. Tabela de cenários.
2. Código do arquivo de teste.
3. Observações sobre riscos ou lacunas.

Exemplo: .github/prompts/review-d365fo-xpp.prompt.md

# Revisar X++ para D365 F&O

Revise o código X++ informado com foco em Dynamics 365 Finance & Operations.

Procure:

- Overlayering ou extensibilidade inadequada.
- Problemas de performance.
- Loops que poderiam usar consultas melhores.
- Transações mal delimitadas.
- Falta de validação funcional.
- Nomes que não explicam regra de negócio.
- Risco de impacto em Finance, SCM, fiscal ou integrações.

Saída:

1. Achados por severidade.
2. Sugestão de correção.
3. Impacto funcional.
4. Testes recomendados.

Exemplo: .github/prompts/write-pr-description.prompt.md

# Criar descrição de PR

Com base nas mudanças locais ou no diff informado, gere uma descrição de pull request.

Formato:

## Resumo
## Motivação
## Alterações principais
## Como testar
## Riscos
## Checklist

Regras:

- Seja claro e direto.
- Não invente testes que não foram executados.
- Destaque mudanças de contrato público, banco de dados, segurança ou performance.

Essa abordagem é o caminho mais prático para criar “skills” utilizáveis no dia a dia do VS2022.

Nível 4: Estrutura SKILL.md

Quando o ambiente oferece suporte a Agent Skills, a estrutura costuma ser uma pasta com um SKILL.md e recursos opcionais.

Exemplo:

.github/
└── skills/
    └── d365fo-code-review/
        ├── SKILL.md
        ├── references/
        │   └── xpp-guidelines.md
        └── assets/
            └── review-template.md

Exemplo de SKILL.md:

---
name: d365fo-code-review
description: Revisa código X++ e integrações de Dynamics 365 F&O com foco em extensibilidade, performance, segurança e impacto funcional. Use quando revisar X++, integrações, queries, Chain of Command ou customizações D365 F&O.
license: MIT
---

# D365 F&O Code Review Skill

Use este skill para revisar alterações técnicas em Dynamics 365 Finance & Operations.

## Processo

1. Identifique o objetivo funcional da alteração.
2. Verifique se a abordagem usa extensibilidade adequada.
3. Procure impacto em performance, transações e consultas.
4. Avalie riscos para Finance, SCM, fiscal, integrações e batch jobs.
5. Confira se há testes ou evidências suficientes.
6. Sugira correções pequenas e fáceis de revisar.

## Critérios de revisão

- Evitar overlayering.
- Preferir Chain of Command quando adequado.
- Não criar consultas custosas dentro de loops.
- Não expor dados sensíveis em logs.
- Validar entradas e estados de negócio.
- Explicar impacto funcional, não apenas técnico.

## Saída esperada

Liste achados por severidade:

- Alta: bug provável, risco de produção, segurança, perda de dados.
- Média: comportamento frágil, performance, manutenção difícil.
- Baixa: clareza, nomenclatura, documentação.

Para cada achado:

- Arquivo ou trecho.
- Problema.
- Por que importa.
- Sugestão de correção.
- Teste recomendado.

Mesmo que seu VS2022 ainda não carregue SKILL.md diretamente, esse arquivo já serve como base para prompt files, documentação interna e futuros agentes.

Nível Opcional: Custom Agents com .agent.md

Custom agents são diferentes de skills. Um agent define um papel, um modelo e um conjunto de ferramentas. Um skill define uma capacidade específica que pode ser reaproveitada por agentes.

Pense assim:

  • Um agent é “quem está trabalhando”: revisor, planejador, depurador, especialista C#.
  • Um skill é “o procedimento que ele sabe executar”: revisar X++, criar testes, preparar PR, analisar performance.

A documentação de custom agents no Visual Studio ainda diferencia recursos por versão. Built-in agents aparecem no ecossistema do Visual Studio 2022 17.14+, enquanto custom agents completos são tratados como recurso mais novo em Visual Studio 2026. Mesmo assim, vale conhecer a estrutura porque ela ajuda a desenhar agentes internos.

Exemplo conceitual: .github/agents/d365fo-reviewer.agent.md

---
name: D365 F&O Reviewer
description: Revisa código e integrações Dynamics 365 F&O com foco em processo, extensibilidade, performance e governança.
tools: ["code_search", "readfile", "find_references"]
---

Você é um revisor técnico especializado em Dynamics 365 Finance & Operations.

Ao revisar uma mudança:

1. Identifique o processo de negócio afetado.
2. Verifique extensibilidade, performance e segurança.
3. Procure risco em integrações, batch jobs, fiscal, Finance e SCM.
4. Confira se há testes ou evidências suficientes.
5. Liste achados por severidade.
6. Sugira correções pequenas e alinhadas ao padrão do projeto.

Não aprove uma mudança apenas porque compila. Explique impacto funcional.

Se o seu ambiente ainda não suportar .agent.md, transforme esse conteúdo em um prompt file ou em uma seção do copilot-instructions.md.

Diferença Entre Instructions, Prompt Files, Agents e Skills

Recurso Melhor uso
copilot-instructions.md Regras gerais do projeto
*.instructions.md Regras por linguagem, pasta ou tipo de arquivo
*.prompt.md Tarefas repetíveis, como gerar testes ou revisar PR
.agent.md Persona e conjunto de ferramentas de um agente
SKILL.md Conhecimento de tarefa específico, portátil e reutilizável
MCP Acesso a ferramentas e fontes externas

Uma forma simples de pensar:

  • Instructions dizem “como responder neste projeto”.
  • Prompt files dizem “execute este procedimento”.
  • Agents dizem “assuma este papel”.
  • Skills dizem “aprenda esta capacidade específica”.
  • MCP diz “use estas ferramentas externas”.

Dicas Avançadas Para Times

1. Crie uma biblioteca de prompts do time

Comece com cinco prompts:

  • Criar testes unitários.
  • Revisar PR.
  • Explicar código legado.
  • Investigar erro.
  • Documentar API ou classe.

Depois evolua com prompts específicos do domínio: D365 F&O, integrações, fiscal, performance, pipelines e migrações.

2. Padronize o “Definition of Done” do Copilot

Exemplo:

Uma resposta só é considerada boa quando:

- Explica as suposições.
- Mantém o padrão do projeto.
- Inclui testes ou recomenda testes.
- Lista riscos.
- Não inventa dependências.
- Não esconde limitações.

3. Use Copilot para onboarding

Prompt:

Sou novo neste projeto. Analise a solução aberta e crie um guia de onboarding com:
arquitetura, projetos principais, fluxo de dados, como rodar localmente, pontos de atenção e primeiro conjunto de tarefas recomendado.

4. Use Copilot para reduzir dívida técnica

Prompt:

Analise esta classe e identifique dívida técnica com baixo risco de correção.
Separe em quick wins, refatorações médias e mudanças que exigem planejamento.

5. Use Copilot como revisor antes do PR humano

Prompt:

Revise minhas mudanças como se fosse um reviewer exigente.
Procure bugs, regressões, falta de teste, problemas de segurança, nomes ruins e documentação ausente.
Não elogie. Liste apenas achados acionáveis.

6. Peça comparação com padrões do projeto

Compare esta implementação com padrões semelhantes já existentes na solução.
Liste divergências e diga se elas parecem justificadas.

7. Transforme erro de build em checklist

Com base nestes erros de build, crie uma ordem de correção.
Explique dependências entre erros e indique quais provavelmente são consequência de outro erro.

8. Use para criar dados de teste

Gere dados de teste realistas para este cenário, cobrindo valores válidos, inválidos, limites e casos de negócio.
Não use dados pessoais reais.

9. Use para revisar logs

Analise estes logs e identifique a sequência provável de eventos.
Liste hipóteses, evidências e próximos passos de diagnóstico.

10. Use para documentação executiva

Transforme esta explicação técnica em um resumo executivo para gestor de TI.
Mantenha precisão, mas remova jargões desnecessários.

Cuidados de Segurança e Governança

Copilot aumenta velocidade. Velocidade sem controle aumenta risco.

Boas práticas:

  • Não cole segredos, tokens, senhas, dados pessoais ou informações contratuais sensíveis no prompt.
  • Revise toda sugestão antes de aceitar.
  • Rode testes automatizados.
  • Use análise estática, lint, code scanning e ferramentas de segurança.
  • Verifique licenças quando a sugestão indicar similaridade com código público.
  • Configure políticas de organização quando estiver em ambiente corporativo.
  • Use exclusão de conteúdo para arquivos que não devem ser considerados pelo Copilot.
  • Não permita que agentes executem comandos sensíveis sem revisão.
  • Em MCP ou skills com scripts, trate como dependência de código: revise origem, comportamento e permissões.

O ponto não é desconfiar da ferramenta. É usar IA com engenharia.

Aplicação em D365 F&O

Para quem trabalha com Microsoft Dynamics 365 Finance & Operations, o Copilot precisa ser usado de um jeito diferente de um projeto .NET comum. D365 F&O não é apenas código X++. É ERP, processo, dados mestres, entidades, batch, segurança, localização, integrações e impacto operacional.

O erro mais comum é pedir algo genérico:

Melhore este código X++.

O pedido certo é mais próximo disso:

Revise esta extensão X++ no contexto de Dynamics 365 F&O.
O objetivo funcional é validar uma regra antes da confirmação de uma ordem de venda.
Considere extensibilidade, Chain of Command, impacto em Sales, performance, transações, segurança e testes SysTest.
Não sugira overlayering.

Essa diferença muda tudo. O Copilot passa a revisar não só sintaxe, mas também risco de processo.

Como Dar Contexto de D365 F&O Para o Copilot

Antes de pedir qualquer coisa, informe o máximo possível destes pontos:

Contexto Por que importa
Módulo afetado Finance, SCM, Sales, Procurement, Projects, Warehouse ou Fiscal têm regras e riscos diferentes
Artefato Classe, tabela, form, data entity, batch, service, event handler, CoC, menu item, privilege
Objetivo funcional Evita que o Copilot trate a mudança como puro código
Ponto de extensão Chain of Command, event handler, table extension, form extension, class extension
Volume esperado Uma rotina para 10 registros é diferente de uma rotina para 5 milhões
Empresa/legal entity Ajuda a lembrar de DataAreaId, crossCompany e escopo de dados
Transação Ajuda a revisar ttsBegin, ttsCommit, forUpdate e rollback
Integração OData, data entity, recurring integration, custom service, business event
Evidência de teste SysTest, Test Explorer, Task Recorder, teste funcional, batch history

Prompt base:

Contexto D365 F&O:
- Módulo:
- Artefato:
- Objetivo funcional:
- Ponto de extensão:
- Volume esperado:
- Legal entity:
- Integrações envolvidas:
- Risco principal:

Tarefa:
[descreva o que você quer]

Critérios:
- Não sugerir overlayering.
- Preservar contrato público.
- Avaliar performance e transação.
- Sugerir testes técnicos e funcionais.
- Explicar impacto no processo de negócio.

Onde o Copilot Mais Ajuda em D365 F&O

1. Entender código X++ legado

Muitos projetos D365 F&O carregam histórico de AX, customizações migradas e nomes que só fazem sentido para quem viveu o projeto desde o início. O Copilot ajuda a transformar código em explicação funcional.

Prompt:

Explique esta classe X++ em linguagem funcional.
Separe em:
1. Objetivo do processo.
2. Tabelas e classes envolvidas.
3. Pontos de extensão usados.
4. Regras de negócio implícitas.
5. Riscos de alterar.
6. Cenários de teste recomendados.

2. Revisar extensibilidade

A documentação da Microsoft é clara: em finance and operations apps, o caminho moderno é extensibilidade. Overlayering não deve ser a abordagem.

Prompt:

Revise esta customização D365 F&O com foco em extensibilidade.
Verifique se a abordagem usa extensão adequada, Chain of Command, event handler ou table/form extension.
Se houver risco de overlayering ou acoplamento excessivo, explique e sugira alternativa.

Checklist que o Copilot deve responder:

  • A alteração toca código padrão ou usa extensão?
  • O ponto de extensão é adequado para o processo?
  • Existe alternativa mais segura por event handler, CoC ou extensão de tabela/form?
  • O método envolvido permite wrapping?
  • A chamada a next está preservada quando necessária?
  • Há risco de quebrar updates futuros da Microsoft?

3. Revisar Chain of Command

Chain of Command é poderoso, mas fácil de usar mal. O Copilot pode revisar estrutura, ordem de execução e impacto funcional.

Prompt:

Revise este Chain of Command em X++.
Verifique:
- Se `next` é chamado corretamente.
- Se a regra antes/depois do `next` faz sentido.
- Se há alteração indevida de parâmetros ou retorno.
- Se existem efeitos colaterais.
- Se a validação deveria estar em outro ponto de extensão.
- Que testes funcionais validam o comportamento.

4. Revisar transações X++

Em D365 F&O, erro transacional pode virar corrupção de dados ou baixa escalabilidade. A própria documentação de X++ destaca verificações como forUpdate e ttsLevel.

Prompt:

Revise a integridade transacional deste código X++.
Procure problemas com:
- `ttsBegin` e `ttsCommit`.
- `forUpdate`.
- Atualização fora do escopo em que o registro foi selecionado.
- Transações longas.
- Chamadas externas dentro de transação.
- Exceções sem rollback claro.

Explique risco de dados e risco de concorrência.

5. Melhorar performance de queries e loops

O Copilot pode ser útil para detectar padrões custosos, mas você precisa pedir com termos de D365 F&O.

Prompt:

Analise este código X++ com foco em performance para D365 F&O.
Procure:
- `while select` com processamento excessivo.
- Consultas dentro de loops.
- Falta de filtros seletivos.
- Uso inadequado de `crossCompany`.
- Atualizações linha a linha que poderiam ser reestruturadas.
- Risco em batch ou volume alto.
- Índices ou campos que deveriam ser avaliados.

Sugira melhorias conservadoras e explique o impacto.

6. Criar e revisar batch jobs

Batch em D365 F&O não é apenas “rodar em background”. Envolve recorrência, histórico, batch groups, prioridades, paralelismo, retry, idempotência e impacto no servidor.

Prompt:

Revise esta classe batch em D365 F&O.
Avalie:
- Se a classe está adequada para execução recorrente.
- Se o processamento é idempotente.
- Se há controle de reprocessamento.
- Se logs e mensagens ajudam suporte.
- Se transações são curtas.
- Se o volume exige paralelismo ou particionamento.
- Se o batch pode ser retomado após falha.

Prompt para desenho:

Desenhe uma abordagem para processar este volume em batch no D365 F&O.
Compare:
1. Processamento sequencial simples.
2. Divisão por tarefas.
3. Particionamento por ranges.
4. Top picking pattern.

Explique prós, contras, riscos e quando usar cada opção.

7. Revisar data entities e integrações

Data entities são o contrato natural de muitos cenários de integração em D365 F&O. Elas encapsulam tabelas e regras de negócio e podem expor OData ou suportar import/export e integrações recorrentes.

Prompt:

Revise esta data entity de D365 F&O.
Avalie:
- Se a entidade representa um conceito de negócio claro.
- Se o contrato público está simples.
- Se os nomes seguem padrão conceitual.
- Se há campos demais para o cenário.
- Se OData faz sentido ou se integração recorrente seria melhor.
- Se há risco de performance para import/export.
- Se a entidade precisa de staging table.

Prompt para escolher integração:

Preciso integrar [cenário] com D365 F&O.
Compare OData, data management/recurring integration, custom service, business events e middleware Azure.
Considere volume, latência, idempotência, retry, segurança OAuth, monitoramento e suporte.
Recomende a abordagem mais segura.

8. Criar testes SysTest e evidências funcionais

O Copilot também deve ajudar a pensar teste no padrão de D365 F&O. A Microsoft documenta o uso de SysTest, Test Explorer, isolamento de testes e geração de testes a partir do Task Recorder.

Prompt:

Crie um plano de testes para esta alteração D365 F&O.
Separe em:
1. Testes SysTest.
2. Testes com dados mínimos.
3. Testes funcionais por tela/processo.
4. Testes de integração.
5. Testes de regressão.
6. Evidências para usuário-chave.

Inclua pré-condições, dados necessários, passo a passo e resultado esperado.

Prompt para SysTest:

Com base nesta regra X++, sugira testes SysTest.
Use nomes no estilo when_given_then.
Priorize isolamento de dados e rollback.
Inclua casos positivos, negativos e limites.
Não invente APIs; se faltar contexto, liste o que precisa ser confirmado no projeto.

9. Traduzir técnico para funcional

Em projeto D365 F&O, muitas decisões passam por consultor funcional, key user e gestor. Copilot ajuda a converter uma explicação técnica em linguagem de processo.

Prompt:

Transforme esta alteração técnica em uma explicação funcional para o consultor de Finance.
Inclua:
- Processo impactado.
- O que muda para o usuário.
- Riscos.
- Dados necessários para teste.
- Cenários que o usuário-chave deve validar.

10. Criar documentação de customização

Prompt:

Gere documentação desta customização D365 F&O em Markdown.
Inclua:
- Objetivo funcional.
- Artefatos alterados.
- Ponto de extensão usado.
- Fluxo técnico.
- Tabelas e entidades envolvidas.
- Integrações impactadas.
- Segurança.
- Testes recomendados.
- Riscos em updates futuros.

Prompts Específicos Para o Dia a Dia D365 F&O

Revisar uma extensão de tabela

Revise esta table extension D365 F&O.
Verifique nomes de campos, labels, EDTs, relações, índices, propriedades obrigatórias, impacto em data entities, impacto em relatórios e necessidade de segurança.
Liste riscos antes de sugerir mudança.

Revisar um form extension

Revise esta form extension.
Avalie se a alteração é adequada para UI de D365 F&O, se os controles seguem padrão, se existe impacto de performance no datasource, se precisa de segurança e quais testes funcionais devem ser feitos.

Criar event handler

Preciso criar um event handler para [evento/processo].
Antes de gerar código, explique se event handler é o ponto correto ou se Chain of Command seria melhor.
Depois sugira a estrutura X++ mínima e os testes.

Revisar custom service

Revise este custom service D365 F&O.
Procure riscos de autenticação, autorização, contrato, validação de entrada, tratamento de erro, idempotência, logs, performance e compatibilidade com integrações externas.

Revisar integração OData

Revise este consumo de OData do D365 F&O.
Avalie filtros, paginação, retry, throttling, autenticação OAuth, tratamento de erro, idempotência e volume.
Sugira quando migrar para integração recorrente ou processamento assíncrono.

Revisar impacto fiscal/localização Brasil

Analise esta alteração D365 F&O considerando localização Brasil.
Procure impacto em NF-e, impostos, dimensões financeiras, documentos fiscais, obrigações acessórias, SPED, integrações fiscais e fechamento.
Se não houver contexto suficiente, liste perguntas para o consultor fiscal.

Criar checklist de passagem para funcional

Crie um checklist para o consultor funcional validar esta alteração.
Inclua configuração, dados mestres, processo ponta a ponta, exceções, relatórios, integrações e evidências.

Um “Skill” D365 F&O Para Copilot

# Skill: Revisão D365 F&O

Use quando revisar código, extensões, integrações ou desenho técnico em Dynamics 365 Finance & Operations.

Contexto obrigatório:
- Módulo afetado.
- Artefato alterado.
- Objetivo funcional.
- Ponto de extensão.
- Volume esperado.
- Legal entity.
- Integrações envolvidas.
- Critério de teste.

Processo:
1. Identificar o processo de negócio.
2. Verificar se a abordagem usa extensibilidade suportada.
3. Revisar transações, queries, loops e batch.
4. Revisar impacto em data entities e integrações.
5. Revisar segurança e dados sensíveis.
6. Sugerir testes SysTest e testes funcionais.
7. Explicar riscos para update, performance e operação.

Saída:
- Resumo funcional.
- Achados por severidade.
- Correções recomendadas.
- Testes recomendados.
- Perguntas abertas.

Esse bloco pode virar:

  • Um prompt file em .github/prompts/review-d365fo.prompt.md.
  • Uma seção de .github/copilot-instructions.md.
  • Um SKILL.md, se o ambiente suportar Agent Skills.
  • Uma checklist de revisão técnica do time.

Checklist D365 F&O Para Revisar Respostas do Copilot

Antes de aceitar qualquer sugestão do Copilot em D365 F&O, revise:

  • A solução usa extensão, não overlayering?
  • O ponto de extensão é o correto?
  • Há impacto em update futuro da Microsoft?
  • O código respeita ttsBegin, ttsCommit, forUpdate e escopo transacional?
  • Existe query dentro de loop?
  • Existe risco com crossCompany?
  • O volume esperado foi considerado?
  • O batch é idempotente?
  • A integração tem retry, logs e monitoramento?
  • OData é adequado ou o cenário pede integração assíncrona?
  • A data entity representa um contrato de negócio claro?
  • Há impacto em segurança, duty, privilege ou role?
  • Há impacto em localização Brasil?
  • Existem testes SysTest ou evidências funcionais?
  • O consultor funcional consegue validar a regra?

A dica mais importante para D365 F&O: sempre peça impacto funcional. Não basta o código compilar; ele precisa respeitar processo, localização, integrações e operação.

Checklist Pessoal Para Usar Copilot Melhor

Antes de pedir:

  • O arquivo certo está aberto?
  • Selecionei o trecho relevante?
  • Expliquei objetivo e restrições?
  • Informei framework, versão e padrão de teste?
  • Pedi plano antes de código quando há risco?

Depois da resposta:

  • Entendi o código?
  • A sugestão segue o padrão do projeto?
  • Existe impacto em contrato público?
  • Há risco de segurança?
  • Precisa de teste?
  • Rodei build/teste relacionado?
  • O diff está pequeno e revisável?

40 Dicas Rápidas

  1. Atualize o Visual Studio 2022 para a versão mais recente.
  2. Use inline completions para código pequeno e repetitivo.
  3. Use chat para raciocínio, explicação e revisão.
  4. Use inline chat para alterar o trecho selecionado.
  5. Abra arquivos relevantes antes de perguntar.
  6. Feche arquivos irrelevantes quando o contexto estiver poluído.
  7. Peça plano antes de código em tarefas arriscadas.
  8. Diga explicitamente o que não pode mudar.
  9. Peça para seguir o padrão existente.
  10. Forneça exemplos de entrada e saída.
  11. Peça edge cases.
  12. Peça testes antes da implementação.
  13. Peça revisão de segurança.
  14. Peça análise de performance.
  15. Peça documentação em Markdown.
  16. Use Mermaid para visualizar fluxo.
  17. Use prints de erro quando a versão do VS permitir imagem no chat.
  18. Reinicie a conversa quando o contexto ficou ruim.
  19. Crie .github/copilot-instructions.md.
  20. Crie instruções por linguagem com .instructions.md.
  21. Crie prompt files para tarefas repetidas.
  22. Versione prompts junto do código.
  23. Revise prompts em PR como qualquer artefato técnico.
  24. Crie um prompt de revisão de PR.
  25. Crie um prompt de geração de testes.
  26. Crie um prompt de análise D365 F&O.
  27. Use Agent Mode para tarefas multi-arquivo, com revisão.
  28. Use MCP quando precisar conectar ferramentas externas.
  29. Nunca cole segredos.
  30. Nunca aceite código que você não consegue explicar.
  31. Em D365 F&O, sempre informe módulo, artefato e processo de negócio.
  32. Peça revisão explícita de extensibilidade antes de aceitar código X++.
  33. Use Copilot para comparar event handler, CoC e extensão antes de implementar.
  34. Peça análise de ttsBegin, ttsCommit, forUpdate e ttsLevel.
  35. Peça avaliação de volume antes de aceitar loops ou while select.
  36. Para batch, peça idempotência, retry, logs, particionamento e retomada.
  37. Para integração, peça comparação entre OData, data entity, business events e processamento assíncrono.
  38. Para Brasil, peça perguntas para fiscal antes de concluir impacto.
  39. Gere sempre testes SysTest ou checklist funcional.
  40. Transforme explicação técnica em evidência para key user validar.

Conclusão

O melhor uso do GitHub Copilot no Visual Studio 2022 não é perguntar “faça isso para mim”. É criar uma forma de trabalho em que a IA recebe contexto, segue padrões, executa tarefas repetíveis e devolve algo que um engenheiro consegue revisar.

O salto de produtividade vem quando você transforma conhecimento tácito em instruções reutilizáveis:

  • Regras gerais em copilot-instructions.md.
  • Regras específicas em .instructions.md.
  • Tarefas repetíveis em .prompt.md.
  • Capacidades mais completas em SKILL.md, quando o ambiente suportar.
  • Ferramentas externas via MCP, quando houver maturidade para isso.

Para times que trabalham com D365 F&O, essa disciplina é ainda mais importante. O Copilot pode acelerar código, testes e documentação, mas a vantagem real está em capturar contexto de processo, arquitetura e operação. É aí que a ferramenta deixa de ser autocomplete e começa a virar uma camada de inteligência prática para o time.

Fontes Oficiais Consultadas