Cartão do aplicativo: sugestões embutidas do GitHub Copilot

O que é um Cartão de Aplicação?

GitHub’s application and platform cards are intended to help you understand how our AI technology works, the choices application owners can make that influence application performance and behavior, and the importance of considering the whole application, including the technology, the people, and the environment. Application cards are created for AI applications and platform cards are created for AI platform services. These resources can support the development or deployment of your own applications and can be shared with users or stakeholders impacted by them.

As part of its commitment to responsible AI, GitHub adheres to Microsoft's six core principles: fairness, reliability and safety, privacy and security, inclusiveness, transparency, and accountability. These principles are embedded in the Responsible AI Standard, which guides teams in designing, building, and testing AI applications. Application and Platform Cards play a key role in operationalizing these principles by offering transparency around capabilities, intended uses, and limitations. For further insight, readers are encouraged to explore Microsoft’s Responsible AI Transparency Report and Termos do GitHub.

1. Visão geral

As sugestões em linha do GitHub Copilot fornecem sugestões no estilo de preenchimento automático enquanto você trabalha. Essas sugestões aparecem em linha no seu editor ou em campos de texto no GitHub.com, ajudando você a escrever código e descrições de pull request mais rapidamente.

As sugestões embutidas do Copilot aparecem de duas formas:

• sugestões embutidas IDE: à medida que você digita código em um editor com suporte, Copilot oferece automaticamente sugestões embutidas para concluir a linha atual, gerar novos blocos de código ou sugerir edições para o código existente. Essas sugestões podem incluir prever o local da próxima edição que você pode querer fazer e o que essa edição deve ser, incluindo exclusões, modificações ou inserções de código. Você pode aceitar toda ou parte de uma sugestão, descartá-la ou continuar digitando para ignorá-la. As sugestões embutidas funcionam em uma ampla gama de linguagens de programação e estruturas.
• Conclusão de texto da solicitação de pull request: ao fazer uma pausa enquanto digita uma descrição de solicitação de pull request no GitHub.com, o Copilot sugere texto para dar continuidade ao que você está escrevendo. A sugestão se baseia no título do pull request, no texto de descrição existente, nos títulos dos commits, nos diffs parciais e nos títulos de pull requests e issues visualizados recentemente. Você pode aceitar a sugestão pressionando Tab ou rejeitando-a continuando a digitar.

O idioma principal com suporte para a conclusão do texto da solicitação de pull é inglês. As sugestões embutidas dão suporte a muitas linguagens de programação, com qualidade variável pelo volume e pela diversidade de dados de treinamento disponíveis para cada idioma.

2. Termos-chave

A lista a seguir apresenta um glossário dos principais termos relacionados às sugestões embutidas do GitHub Copilot:

• Filtragem de conteúdo: um sistema de segurança que verifica solicitações e respostas para detectar e bloquear conteúdo prejudicial, ofensivo ou inseguro antes de ser mostrado ao usuário.
• Alucinação: um fenômeno em que um modelo de linguagem gera uma saída que soa plausível, mas que é factualmente incorreta, sem suporte pelo contexto fornecido ou totalmente fabricada. Alucinações são um risco conhecido de modelos de linguagem grandes e são um motivo fundamental para que a revisão humana da saída gerada por IA seja importante.
• Sugestão embutida: Uma sugestão de código gerada por IA do Copilot que é exibida no editor enquanto você digita. As sugestões embutidas podem concluir a linha atual ou propor edições ao código existente, prevendo onde a próxima alteração deve ocorrer e o que essa alteração deve ser, incluindo inserir, modificar ou excluir código. As sugestões podem aparecer no cursor ou direcionar os usuários para outros locais relevantes na base de código, onde podem ser aceitas, descartadas ou ignoradas ao continuar digitando.
• LLM (modelo de linguagem grande): um tipo de rede neural treinada em um grande corpo de dados de texto que pode gerar, analisar e transformar linguagem natural e código. As sugestões embutidas do Copilot usam um ou mais LLMs para processar o contexto e gerar sugestões.
• A correspondência de código público: um recurso de segurança que verifica se as sugestões de Copilot correspondem ao código disponível publicamente. Dependendo de suas configurações, as sugestões correspondentes são bloqueadas ou anotadas com uma referência ao repositório de origem e qualquer informação de licença.
• Preenchimento automático de texto para pull requests: uma sugestão de preenchimento automático para descrições de pull request no GitHub.com. Quando você faz uma pausa ao digitar, o Copilot sugere texto para dar continuidade ao que você está escrevendo com base no contexto do pull request.
• Dados de treinamento: o grande volume de texto e código disponíveis publicamente que foi usado para treinar os modelos fundamentais por trás das sugestões embutidas do Copilot. A composição dos dados de treinamento influencia a qualidade e a cobertura das sugestões do modelo em diferentes linguagens de programação, estruturas e tópicos.

3. Principais funcionalidades ou capacidades

Os principais recursos e funcionalidades descritos aqui explicam o que as sugestões embutidas do GitHub Copilot se destinam a fazer e como elas funcionam nas tarefas compatíveis.

• Inline code suggestions: à medida que você digita código em um editor com suporte, Copilot oferece automaticamente sugestões embutidas que podem concluir a linha atual, gerar novos blocos de código ou propor edições para o código existente. Essas sugestões podem incluir a inserção, modificação ou exclusão de código, comentários de código, testes e muito mais, prevendo quais alterações devem ser feitas e onde na base de código elas devem ocorrer. As sugestões podem aparecer no cursor ou orientar os usuários para outros locais de edição relevantes e podem ser aceitas na íntegra ou em parte, descartadas ou ignoradas continuando a digitar.
• Geração de código orientada a comentários: você pode orientar sugestões embutidas escrevendo comentários de código que descrevem o código esperado. Por exemplo, comentários como "usar recursão" ou "usar um padrão singleton" influenciam o tipo de algoritmo que Copilot sugere.
• Suporte a vários idiomas: as sugestões embutidas funcionam em uma ampla gama de linguagens de programação e estruturas. A qualidade das sugestões depende do volume e da diversidade dos dados de treinamento disponíveis para cada idioma. Para obter uma lista de linguagens de programação desenvolvidas ativamente encontradas em GitHub, consulte Programming languages.
• Conclusão de texto para pull request: quando você faz uma pausa ao digitar a descrição de um pull request no GitHub.com, o Copilot sugere um texto para continuar o que você estava escrevendo. A sugestão se baseia no título do pull request, no texto de descrição existente, nos títulos dos commits, nos diffs parciais e nos títulos de pull requests e issues visualizados recentemente.

4. Utilizações pretendidas

As sugestões em linha do GitHub Copilot podem ser usadas em diversos cenários em diferentes setores. Alguns exemplos de casos de utilização incluem:

• Acelerando a criação de código: os desenvolvedores podem usar sugestões embutidas para trabalhar mais rapidamente aceitando as alterações previstas à medida que digitam, incluindo a conclusão do código, a geração de novos blocos ou a modificação do código existente. As sugestões podem inserir, atualizar ou excluir código na linha atual ou em outros locais relevantes no arquivo antecipando quais alterações devem ser feitas e onde elas devem ocorrer. Isso é particularmente útil para código clichê, padrões repetitivos, idiomas comuns e manter a consistência à medida que o código evolui entre linguagens e estruturas compatíveis.
• Generating unit tests: Copilot pode sugerir casos de teste com base no código ao redor, incluindo possíveis parâmetros de entrada, valores de saída esperados e asserções. Isso ajuda os desenvolvedores a criar uma cobertura de teste mais rapidamente, incluindo casos de borda e condições de limite que podem ser difíceis de identificar manualmente. Os testes gerados ainda devem ser revisados, pois podem não abranger todos os cenários.
• Geração de código guiada por comentários: os desenvolvedores podem escrever comentários em linguagem natural descrevendo o código de que precisam, e o Copilot gera implementações ou modificações correspondentes. Isso pode ser útil para especificar algoritmos, padrões de design ou métodos e propriedades a serem adicionados a uma classe.
• Redigir descrições de pull request: ao escrever uma descrição de pull request no GitHub.com, o Copilot pode sugerir texto para dar continuidade ao que você está escrevendo, ajudando você a escrever mais rapidamente resumos claros das suas alterações.

5. Modelos e dados de preparação

As sugestões embutidas do GitHub Copilot usam uma variedade de modelos de IA para viabilizar a experiência apresentada aos usuários. Para obter uma comparação dos modelos disponíveis para Copilot, consulte Comparação de modelos de IA. Para obter a lista completa de modelos com suporte, consulte Modelos de IA com suporte no GitHub Copilot. Para obter informações sobre onde os modelos estão hospedados, consulte Hospedagem de modelos para GitHub Copilot. Para saber mais sobre os dados usados para treinar os modelos fundamentais por trás das sugestões embutidas do GitHub Copilot, consulte a comparação de modelos de IA vinculada acima e Em quais dados o GitHub Copilot foi treinado? no FAQ do GitHub Copilot.

A funcionalidade de completar texto em pull requests usa um fluxo de prompt simples que utiliza a API do Copilot com um modelo de linguagem de grande porte genérico. Nenhum modelo treinado adicional é usado para esse recurso.

6. Desempenho

As sugestões em linha do Copilot funcionam por meio da combinação de processamento de linguagem natural e aprendizado de máquina para entender o contexto ao redor e fornecer sugestões. Esse processo segue um fluxo padronizado:

1. Processamento de entrada: o código ao redor da posição do cursor é pré-processado pelo sistema de sugestões em linha, combinado com informações contextuais (como trechos de código de abas abertas no editor) e enviado a um grande modelo de linguagem na forma de um prompt. Para obter informações sobre retenção de dados, consulte a Central de Confiabilidade Copilot.
2. Análise do modelo de linguagem: um modelo de linguagem grande processa o prompt de entrada. Para sugestões embutidas, o modelo gera sugestões embutidas e edições previstas com base no contexto dos arquivos atuais e abertos no editor, incluindo inserir, modificar ou excluir código antecipando quais alterações devem ser feitas e onde elas devem ocorrer. Para a conclusão do texto da solicitação de pull, Copilot usa um modelo de idioma por meio da API Copilot.
3. Geração de resposta: o modelo de linguagem gera uma resposta com base na análise do prompt de entrada e no contexto fornecido. Para sugestões embutidas, isso pode assumir a forma de concluir o código, gerar novos blocos ou propor alterações no código existente (incluindo exclusões) prevendo quais edições devem ser feitas e onde na base de código elas devem ocorrer. Para completar o texto de um pull request, a resposta é uma continuação em prosa da descrição.
4. Formatação de saída: a resposta é apresentada embutida no editor como uma alteração sugerida que é visualmente distinta do conteúdo ao redor. As sugestões podem aparecer no cursor ou perto do cursor, bem como realçar outros locais relevantes na base de código em que as edições são propostas e só serão aplicadas ao campo de arquivo ou texto se você as aceitar explicitamente.

As sugestões embutidas do Copilot foram projetadas para oferecer as sugestões mais relevantes e úteis para complementar seu trabalho atual. No entanto, eles podem nem sempre fornecer as respostas que você está procurando. Os usuários são responsáveis por revisar e validar sugestões antes de aceitá-las para garantir que elas sejam precisas e apropriadas. Como parte do processo de desenvolvimento do produto, as sugestões geradas são executadas por meio de filtros de conteúdo. O sistema de filtragem de conteúdo detecta e bloqueia conteúdo prejudicial ou ofensivo ou código inseguro. Dependendo das configurações de GitHub, o filtro também bloqueia ou anota sugestões que contêm correspondências ao código público.

Diferenças por experiência

Sugestões em linha (IDE)

As sugestões em linha usam modelos de linguagem ajustados especificamente para essa tarefa. Eles analisam o código em torno do seu trabalho atual, juntamente com o contexto da base de código e do sistema dos usuários. Com base nessa análise, o sistema pode concluir o código, gerar novos blocos ou propor edições (incluindo exclusões) ao código existente, prevendo quais alterações devem ser feitas e onde na base de código elas devem ocorrer. O sistema destina-se apenas a ajudar nas tarefas de codificação.

Conclusão do texto da solicitação de pull (GitHub.com)

A conclusão do texto da solicitação de pull usa um fluxo de prompt simples aproveitando a API de Copilot com um modelo de linguagem grande genérico. Quando você faz uma pausa ao escrever a descrição de um pull request, o sistema combina o título do pull request, o texto de descrição existente, os títulos dos commits, os diffs parciais e os títulos de pull requests e issues visualizados recentemente para sugerir um texto que dê continuidade ao que você está escrevendo. O idioma principal com suporte é inglês.

7. Limitações

Entender as limitações das sugestões em linha do GitHub Copilot é crucial para determinar que elas sejam usadas dentro de limites seguros e eficazes. Embora incentivemos os clientes a usar as sugestões embutidas do Copilot em suas soluções ou aplicativos inovadores, é importante observar que as sugestões embutidas do Copilot não foram projetadas para atender a todos os cenários possíveis. Incentivamos os usuários a se referirem a Termos do GitHub , bem como às seguintes considerações ao escolher um caso de uso:

• Escopo limitado: as sugestões embutidas são treinadas em um grande corpo de código, mas ainda têm um escopo limitado e podem não ser capazes de lidar com estruturas de código mais complexas ou linguagens de programação obscuras. Para cada idioma, a qualidade das sugestões depende do volume e da diversidade dos dados de treinamento para esse idioma. Por exemplo, o JavaScript é bem representado em repositórios públicos e é um dos idiomas com melhor suporte. Idiomas com menos representação em repositórios públicos podem ser mais desafiadores para ajudar. Além disso, sugestões embutidas só podem sugerir código com base no contexto do código que está sendo escrito, portanto, elas podem não ser capazes de identificar problemas maiores de design ou arquitetura. As sugestões embutidas destinam-se a gerar código e saídas relacionadas a código, não respostas em linguagem natural.
• Possíveis vieses: As fontes dos dados de treinamento do Copilot podem conter vieses e erros que podem ser perpetuados pela ferramenta. Além disso, as sugestões embutidas podem ser tendenciosas em relação a determinadas linguagens de programação ou estilos de codificação, o que pode levar a sugestões de código abaixo do ideal ou incompletas.
• Os riscos de segurança: Copilot gera código com base no contexto do código que está sendo escrito, o que pode potencialmente expor informações confidenciais ou vulnerabilidades se não for usado com cuidado. Você deve ter cuidado ao usar Copilot para gerar código para aplicativos sensíveis à segurança e sempre examinar e testar o código gerado minuciosamente.
• Correspondências com o código público: as sugestões embutidas são capazes de gerar um novo código, o que elas fazem de forma probabilística. Embora a probabilidade seja baixa, Copilot pode gerar sugestões de código que correspondem ao código no conjunto de treinamento.
• Inaccurate code: Copilot pode gerar um código que parece ser válido, mas pode não estar realmente semanticamente ou sintaticamente correto ou não refletir com precisão a intenção do desenvolvedor. Para atenuar o risco de código impreciso, revise e teste cuidadosamente o código gerado, ainda mais ao lidar com aplicativos críticos ou confidenciais. Você também deve garantir que o código gerado siga práticas recomendadas e os padrões de design e se encaixe na arquitetura geral e no estilo da base de código.
• Pull requests grandes podem reduzir a qualidade das sugestões: em pull requests muito grandes, parte do conteúdo do pull request em que o Copilot se baseia para completar texto pode não caber na chamada à API. Como resultado, algumas sugestões que você pode esperar podem não aparecer ou podem ser menos contextualmente precisas.
• Risco de alucinação na conclusão de texto em pull requests: como a conclusão de texto em pull requests é gerada por um modelo de linguagem de grande porte, há risco de alucinação — em que o Copilot gera afirmações que parecem plausíveis, mas são factualmente imprecisas. Examinar cuidadosamente o texto gerado antes da publicação é essencial.
• Replicação do conteúdo da solicitação de pull: a conclusão do texto da solicitação de pull se baseia no conteúdo da solicitação de pull em si. Se termos prejudiciais ou ofensivos aparecerem no conteúdo da solicitação de pull (como mensagens de confirmação ou difusões), há a possibilidade de que a sugestão também possa incluir esses termos.
• Suporte ao idioma: o idioma principal com suporte para a conclusão do texto da solicitação de pull é inglês. As sugestões embutidas dão suporte a muitas linguagens de programação, com qualidade variável pelo volume e pela diversidade de dados de treinamento disponíveis para cada idioma.

8. Avaliações

As avaliações de desempenho e segurança avaliam se as aplicações de IA estão a funcionar de forma fiável e segura ao examinar fatores como a fundamentação, a relevância e a coerência, ao mesmo tempo que identificam os riscos de gerar conteúdo prejudicial. As avaliações a seguir foram realizadas com componentes de segurança já em vigor, que também são descritos em 9. Componentes de segurança e mitigações.

Avaliações de desempenho e qualidade

As sugestões embutidas do GitHub Copilot são avaliadas por meio de um sistema de avaliação offline e online multicamadas, projetado para avaliar a qualidade das sugestões, a relevância e o valor para os desenvolvedores. O sistema também foi projetado para habilitar a iteração rápida do modelo, mantendo padrões de alta qualidade.

Métodos de avaliação de desempenho e qualidade

Para avaliação offline, usamos um conjunto de conjuntos de testes que abrangem os principais cenários de sugestão embutida em várias linguagens de programação. Os modelos são avaliados em relação às saídas esperadas para detectar regressões em comportamentos principais, como correção de código e relevância contextual. Também comparamos modelos candidatos com baselines de produção por meio da avaliação da qualidade da saída, da coerência e do alinhamento com a intenção do desenvolvedor.

Para avaliação online, implementamos modelos candidatos em segmentos controlados de usuários para medir a taxa de aceitação, a taxa de exibição, a qualidade das edições e a retenção.

Nossas avaliações acompanham a latência, o uso de token e o volume de computação juntamente com as métricas de qualidade para garantir que os modelos forneçam valor dentro das restrições operacionais.

Também aproveitamos as experiências dos desenvolvedores internos da Microsoft e do GitHub para avaliar modelos candidatos em condições reais de desenvolvimento, fornecendo feedback qualitativo e indícios iniciais sobre comportamentos em casos-limite antes de uma implantação mais ampla.

Avaliações de risco e segurança

A avaliação de potenciais riscos associados ao conteúdo gerado pela IA é essencial para salvaguardar os riscos de conteúdo com diferentes graus de gravidade. Isto inclui avaliar a predisposição de uma aplicação de IA para gerar conteúdo prejudicial ou testar vulnerabilidades para ataques de jailbreak. Para GitHub, realizamos avaliações de desempenho, incluindo aquelas adaptadas para fins de codificação de Microsoft Foundry:

• Ódio e injustiça
• Sexual
• Violência
• Automutilação
• Material protegido
• Desbloqueio
• Vulnerabilidade de código

Métodos de avaliação de risco e segurança

Teste de adversário: quando o modelo base é atualizado ou alterações significativas são feitas no treinamento de fontes de dados (como a incorporação de um novo tipo de conjunto de dados), o modelo passa por testes de segurança em que é deliberadamente desafiado com entradas projetadas para provocar saídas prejudiciais, inseguras ou que violam políticas. Esse teste abrange várias categorias de risco, incluindo conteúdo prejudicial, riscos de propriedade intelectual e geração de código insegura. Os resultados são comparados com as linhas de base de produção e, se houver regressões, passarão por revisão manual para avaliar o verdadeiro risco.

Dados de avaliação para qualidade e segurança

Os nossos dados de avaliação são personalizados para avaliar o desempenho da aplicação de IA em áreas-chave de segurança e qualidade, simulando cenários e riscos do mundo real. Começamos identificando aspectos de avaliação relevantes de preocupação com base em pesquisas multidisciplinares e na contribuição de especialistas. Essas questões são traduzidas em objetivos de avaliação direcionados e orientam a formulação das métricas de avaliação. Para segurança, criamos prompts adversários para elicitar respostas indesejáveis ou em casos extremos, os quais são avaliados por avaliadores assistidos por IA treinados para verificar a conformidade com os padrões do GitHub. Em qualidade, criamos prompts com base em rubricas relevantes para cenários como a avaliação de aplicações e agentes de geração aumentada por recuperação (RAG). Os conjuntos de dados são coletados de diversas fontes, incluindo conjuntos de dados sintéticos e públicos para simular cenários de usuários reais. Usando os conjuntos de dados coletados, ambas as avaliações passam por refinamento iterativo e alinhamento humano para melhorar a eficácia e a confiabilidade da métrica. Essa metodologia forma a base de avaliações repetíveis e rigorosas que refletem como os clientes usam avaliações para criar uma IA melhor.

Avaliações personalizadas

As sugestões embutidas do Copilot foram submetidas a red teaming de RAI para identificar e mitigar possíveis riscos de segurança. Continuamos monitorando a eficácia e a segurança do recurso ao longo do tempo. Para obter mais informações, consulte Microsoft AI Red Team criando o futuro da IA mais segura no blog de segurança do Microsoft.

9. Componentes de segurança e mitigações

As sugestões em linha do GitHub Copilot utilizam uma arquitetura de segurança com várias camadas de proteção em todo o pipeline de sugestão.

• Processamento de entrada e saída: o contexto do código — incluindo histórico de edição, código circundante e posição do cursor — é estruturado e delimitado antes de chegar ao modelo de linguagem. O modelo é restrito a uma tarefa estreita (prevendo a próxima edição de código dentro de uma janela definida) e deve seguir um formato de saída estrito, produzindo apenas edições de código em vez de respostas de forma livre. O prompt do sistema também impõe a adesão às políticas de conteúdo, com uma resposta de recusa obrigatória para solicitações que podem violar as diretrizes.
• Filtros de segurança de conteúdo e código: o GitHub Copilot inclui filtros de segurança projetados para reduzir resultados prejudiciais ou inadequados e desestimular o uso indevido. Os usuários ainda devem examinar sugestões antes de usá-las.
• A correspondência de código público: GitHub Copilot usa um sistema de detecção de duplicação projetado para identificar quando as sugestões correspondem ao código disponível publicamente. Organizações e indivíduos podem configurar isso para bloquear sugestões correspondentes ou fornecer referências de código com informações de repositório e licença.
• Supervisão humana: as sugestões embutidas seguem os princípios humanos no loop— as sugestões são visualmente distintas do conteúdo ao redor e só são aplicadas quando o usuário as aceita explicitamente. Nenhuma alteração de código ocorre sem ação deliberada do usuário. Os usuários são incentivados a revisar, testar e validar todas as sugestões geradas.

10. Práticas recomendadas para implantar e adotar sugestões embutidas do GitHub Copilot

A IA responsável é um compromisso compartilhado entre GitHub e seus clientes. Embora GitHub crie aplicativos de IA com segurança, imparcialidade e transparência no núcleo, os clientes desempenham um papel fundamental na implantação e no uso dessas tecnologias de forma responsável dentro de seus próprios contextos. Para apoiar esta parceria, oferecemos as seguintes melhores práticas para implementadores e utilizadores finais para ajudar os clientes a implementar a IA responsável de forma eficaz.

• Tenha cautela e avalie os resultados ao usar sugestões do Copilot para decisões de grande impacto ou em áreas sensíveis: As decisões conseqüentes são aquelas que podem ter um impacto legal ou significativo no acesso de uma pessoa à educação, emprego, plataformas financeiras, benefícios governamentais, saúde, moradia, seguro, plataformas legais, ou que podem resultar em danos físicos, psicológicos ou financeiros. Domínios confidenciais, como plataformas financeiras, saúde e moradia, exigem cuidados específicos devido ao potencial de impacto desproporcional em diferentes grupos de pessoas. Ao utilizar a IA para decisões nestas áreas, certifique-se de que os intervenientes afetados conseguem compreender como as decisões são tomadas, tomar decisões de recurso e atualizar quaisquer dados de entrada relevantes.
• Avalie as considerações legais e regulatórias: Os clientes precisam avaliar possíveis obrigações legais e regulatórias específicas ao usar quaisquer plataformas e soluções de IA, que podem não ser apropriadas para uso em todos os setores ou cenários. Além disso, as plataformas ou soluções de IA não são projetadas e podem não ser usadas de maneiras proibidas em termos de serviço aplicáveis e códigos de conduta relevantes.
• Mantenha os prompts no tópico: as sugestões em linha do Copilot destinam-se exclusivamente a gerar código ou sugestões relacionadas a código. Limitar o conteúdo do editor a código ou a informações relacionadas à programação pode melhorar a qualidade das sugestões.
• Forneça um bom contexto para a conclusão do texto da solicitação de pull: a qualidade das sugestões de conclusão de texto da solicitação de pull depende da qualidade do título da solicitação de pull, mensagens de confirmação e qualquer texto já na descrição. Fornecer títulos claros e descritivos e mensagens de confirmação melhorará a relevância das sugestões. Continua sendo sua responsabilidade revisar e avaliar a precisão das informações nas pull requests que você cria.
• Use sugestões embutidas Copilot como uma ferramenta, não uma substituição: embora Copilot possa ser uma ferramenta poderosa para gerar código, é importante usá-lo como uma ferramenta e não como um substituto para a programação humana. Você sempre deve examinar as sugestões de Copilot antes de aceitá-las e validá-las posteriormente para garantir que ela atenda aos seus requisitos e esteja livre de erros ou problemas de segurança.
• Exercite a supervisão humana quando apropriado: a supervisão humana é uma proteção importante ao interagir com aplicativos de IA. Embora melhoremos continuamente nossos aplicativos de IA, a IA ainda pode cometer erros. As saídas geradas podem ser imprecisas, incompletas, tendenciosas, desalinhadas ou irrelevantes para os objetivos pretendidos. Isto pode acontecer devido a várias razões, como ambiguidade nas entradas ou limitações dos modelos subjacentes. Dessa forma, os usuários devem examinar as respostas geradas por Copilot sugestões embutidas e verificar se correspondem às suas expectativas e requisitos.
• Esteja ciente do risco de dependência excessiva: A dependência excessiva da IA ocorre quando os usuários aceitam saídas de IA incorretas ou incompletas, principalmente porque erros em saídas de IA podem ser difíceis de detectar. Para o utilizador final, a sobre-confiança pode resultar numa diminuição da produtividade, perda de confiança, abandono de aplicações, perda financeira, danos psicológicos, danos físicos, entre outros. (por exemplo, um médico aceita uma saída de IA incorreta).
• Tenha cuidado ao criar IA agente em domínios confidenciais: Os usuários devem ter cuidado ao projetar e/ou implantar aplicativos de IA agente em domínios confidenciais em que as ações do agente são irreversíveis ou altamente conseqüentes. Precauções adicionais também devem ser tomadas ao criar IA agente autônoma, conforme descrito mais adiante no Termos do GitHub.
• Use práticas seguras de codificação e revisão de código: embora sugestões embutidas possam gerar código sintaticamente correto, ele pode nem sempre ser seguro. Você sempre deve seguir as práticas recomendadas para codificação segura, como evitar senhas codificadas ou vulnerabilidades de injeção de SQL, bem como seguir as práticas recomendadas de revisão de código.
• Mantenha-se atualizado: as sugestões em linha do Copilot ainda são uma tecnologia em evolução. Esteja sempre em dia com as atualizações ou alterações na ferramenta, bem como novos riscos de segurança ou práticas recomendadas que possam surgir. As atualizações de extensão automatizadas são habilitadas por padrão em Visual Studio Code, Visual Studio e no pacote jetbrains de IDEs.

11. Saiba mais sobre as sugestões embutidas do GitHub Copilot

Para obter orientações adicionais sobre o uso responsável das sugestões embutidas do Copilot, recomendamos consultar a documentação a seguir:

• Obtendo sugestões de código em seu IDE com GitHub Copilot
• Termos do GitHub para produtos e recursos adicionais
• Central de Confiabilidade do Copilot

Saiba mais sobre IA responsável

• Princípios de IA da Microsoft
• Recursos de IA responsável da Microsoft
• Cursos do Microsoft Azure Learning sobre IA responsável