Práticas recomendadas para usar GitHub Copilot para trabalhar em tarefas

Certificar-se de que seus issues têm um escopo bem definido

          GitHub Copilot fornece melhores resultados quando atribuídas tarefas claras e bem definidas. Uma tarefa ideal inclui:

• Uma descrição clara do problema a ser resolvido ou do trabalho necessário.
• Critérios de aceitação completos sobre como é uma boa solução (por exemplo, deve haver testes de unidade?).
• Instruções sobre quais arquivos precisam ser alterados.

          agente de codificação Copilot tem a capacidade de pesquisar sua base de código, incluindo a pesquisa semântica de código, o que ajuda a encontrar código relevante com base no significado, em vez de apenas correspondências de texto exatas. Mesmo que você não especifique caminhos de arquivo exatos em uma tarefa, o agente geralmente pode descobrir o código certo por conta própria.

Se você repassar uma tarefa para Copilot atribuindo um problema, será útil pensar no problema atribuído a Copilot como um prompt. Considere se a descrição do problema provavelmente funcionará como um prompt de IA e permitirá Copilot fazer as alterações de código necessárias.

Escolhendo o tipo certo de tarefas para delegar Copilot

Ao trabalhar com Copilot, você terá uma noção dos tipos de tarefas para as quais ele é mais adequado. Inicialmente, talvez você queira começar dando Copilot tarefas mais simples para ver como ele funciona como um agente de codificação. Por exemplo, você pode começar solicitando Copilot para corrigir bugs, alterar recursos de interface do usuário, melhorar a cobertura de teste, atualizar a documentação, melhorar a acessibilidade ou resolver dívidas técnicas.

Os problemas que você pode escolher resolver por conta própria, em vez de atribuir a Copilot, incluem:

•         **Tarefas complexas com escopo amplo**
  

  • Problemas de refatoração com escopo amplo e contexto complexo, que exigem conhecimento e testes entre repositórios
  • Issues complexos que exigem a compreensão de dependências e código herdado
  • Tarefas que exigem conhecimento profundo do domínio
  • Tarefas que envolvem lógica de negócios substancial
  • Alterações grandes em uma base de código que exigem consistência de design

•         **Tarefas confidenciais e críticas**
  

  • Issues críticos para a produção
  • Tarefas que envolvem segurança, informações de identificação pessoal, repercussões para a autenticação
  • Resposta a incidente

•         **Tarefas ambíguas**
  

  • Tarefas sem definição clara: tarefas com requisitos ambíguos, tarefas com várias soluções, tarefas que exigem trabalhar com incertezas para encontrar uma solução

•         **Tarefas de aprendizagem**
  

  • Tarefas em que o desenvolvedor quer aprender, a fim de obter uma compreensão mais profunda

Usar comentários para iterar em uma pull request

Trabalhar com um Copilot em uma pull request é como trabalhar com um desenvolvedor humano: é comum que a pull request precise de mais trabalho antes que ela possa ser integrada. O processo para que a solicitação de pull se torne mesclável é exatamente o mesmo quando a solicitação de pull é criada por Copilot ou por um humano.

Além disso, você pode:

• Mencione @copilot nos comentários da solicitação de pull, explicando o que você acha que está incorreto ou pode ser melhorado, e Copilot enviará commits diretamente para o branch da solicitação de pull.
• Solicite Copilot para resolver conflitos de mesclagem na solicitação de pull. Confira Solicitando GitHub Copilot fazer alterações em uma solicitação de pull existente.
• Trabalhe no branch de feature por conta própria e faça push das alterações para o pull request.

Depois que um usuário com acesso de gravação menciona @copilot em um comentário, Copilot começará a fazer as alterações necessárias e atualizará a solicitação de pull quando terminar. Como Copilot começa a examinar os comentários assim que eles são enviados, se você provavelmente fizer vários comentários em uma solicitação de pull, é melhor enviá-los em lote clicando em Iniciar uma revisão, em vez de clicar em Adicionar comentário único. Em seguida, você pode enviar todos os seus comentários de uma só vez, disparando Copilot para trabalhar em toda a sua revisão, em vez de trabalhar em comentários individuais separadamente.

À medida Copilot que faz alterações no pull request, manterá o título e o corpo atualizados, de modo que refletem as mudanças correntes.

Adicionar instruções personalizadas ao repositório

Adicionando instruções personalizadas ao repositório, você pode orientar Copilot sobre como entender seu projeto e como criar, testar e validar suas alterações.

Se Copilot for capaz de criar, testar e validar suas alterações em seu próprio ambiente de desenvolvimento, é mais provável que ele produza boas solicitações de pull que podem ser mescladas rapidamente.

          agente de codificação Copilot dá suporte a vários tipos diferentes de arquivos de instruções personalizados:

• /.github/copilot-instructions.md
• /.github/instructions/**/*.instructions.md
• **/AGENTS.md
• /CLAUDE.md
• /GEMINI.md

Para obter mais informações, consulte Adicionando instruções personalizadas do repositório para GitHub Copilot.

Instruções para todo o repositório

Para adicionar instruções que se aplicam a todas as tarefas atribuídas a Copilot no seu repositório, crie um arquivo .github/copilot-instructions.md na raiz do seu repositório. Esse arquivo deve conter informações sobre seu projeto, como como compilá-lo e testá-lo e quaisquer padrões de codificação ou convenções que você deseja Copilot seguir. Observe que as instruções também serão aplicadas a Chat Copilot e Revisão de código com Copilot.

A primeira vez que você pedir Copilot para criar uma solicitação de pull em um determinado repositório, Copilot deixará um comentário com um link para gerar instruções personalizadas automaticamente. Você também pode solicitar que Copilot gere instruções personalizadas para você a qualquer momento usando nosso prompt recomendado. Confira Adicionando instruções personalizadas do repositório para GitHub Copilot.

Você também pode optar por escrever suas próprias instruções personalizadas a qualquer momento. Aqui está um exemplo de um arquivo copilot-instructions.md eficaz:

This is a Go based repository with a Ruby client for certain API endpoints. It is primarily responsible for ingesting metered usage for GitHub and recording that usage. Please follow these guidelines when contributing:

## Code Standards

### Required Before Each Commit
- Run `make fmt` before committing any changes to ensure proper code formatting
- This will run gofmt on all Go files to maintain consistent style

### Development Flow
- Build: `make build`
- Test: `make test`
- Full CI check: `make ci` (includes build, fmt, lint, test)

## Repository Structure
- `cmd/`: Main service entry points and executables
- `internal/`: Logic related to interactions with other GitHub services
- `lib/`: Core Go packages for billing logic
- `admin/`: Admin interface components
- `config/`: Configuration files and templates
- `docs/`: Documentation
- `proto/`: Protocol buffer definitions. Run `make proto` after making updates here.
- `ruby/`: Ruby implementation components. Updates to this folder should include incrementing this version file using semantic versioning: `ruby/lib/billing-platform/version.rb`
- `testing/`: Test helpers and fixtures

## Key Guidelines
1. Follow Go best practices and idiomatic patterns
2. Maintain existing code structure and organization
3. Use dependency injection patterns where appropriate
4. Write unit tests for new functionality. Use table-driven unit tests when possible.
5. Document public APIs and complex logic. Suggest changes to the `docs/` folder when appropriate

Instruções específicas de caminho

Para adicionar instruções que se aplicam a tipos específicos de arquivos Copilot , como testes de unidade ou componentes do React, crie um ou mais .github/instructions/**/*.instructions.md arquivos em seu repositório. Nesses arquivos, inclua informações sobre os tipos de arquivo, como como compilá-los e testá-los e quaisquer padrões ou convenções de codificação que você deseja Copilot seguir.

Usando o padrão glob na parte inicial do arquivo de instruções, você pode especificar os tipos de arquivo aos quais eles devem ser aplicados. Por exemplo, para criar instruções para testes do Dramaturgo, você pode criar um arquivo de instruções chamado .github/instructions/playwright-tests.instructions.md com o seguinte conteúdo:

---
applyTo: "**/tests/*.spec.ts"
---

## Playwright test requirements

When writing Playwright tests, please follow these guidelines to ensure consistency and maintainability:

1. **Use stable locators** - Prefer `getByRole()`, `getByText()`, and `getByTestId()` over CSS selectors or XPath
1. **Write isolated tests** - Each test should be independent and not rely on other tests' state
1. **Follow naming conventions** - Use descriptive test names and `*.spec.ts` file naming
1. **Implement proper assertions** - Use Playwright's `expect()` with specific matchers like `toHaveText()`, `toBeVisible()`
1. **Leverage auto-wait** - Avoid manual `setTimeout()` and rely on Playwright's built-in waiting mechanisms
1. **Configure cross-browser testing** - Test across Chromium, Firefox, and WebKit browsers
1. **Use Page Object Model** - Organize selectors and actions into reusable page classes for maintainability
1. **Handle dynamic content** - Properly wait for elements to load and handle loading states
1. **Set up proper test data** - Use beforeEach/afterEach hooks for test setup and cleanup
1. **Configure CI/CD integration** - Set up headless mode, screenshots on failure, and parallel execution

Instruções personalizadas em toda a organização

          agente de codificação Copilot aproveita as instruções personalizadas da sua organização como parte de seu trabalho. 
          agente de codificação Copilot primeiro prioriza instruções personalizadas em todo o repositório. Para obter mais informações sobre como configurar instruções personalizadas da organização, consulte [AUTOTITLE](/copilot/how-tos/configure-custom-instructions/add-organization-instructions).

Usando o Protocolo de Contexto de Modelo (MCP)

Você pode estender os recursos agente de codificação Copilot usando o MCP. Isso permite usar ferramentas fornecidas agente de codificação Copilot por servidores MCP locais e remotos. O GitHub servidor MCP e o servidor MCP do Dramaturgo são habilitados por padrão. Para obter mais informações, consulte Estendendo o agente de codificação do GitHub Copilot com o protocolo de contexto do modelo (MCP).

Criar agentes personalizados

Embora as instruções personalizadas ajudem a orientar o comportamento geral em todo o seu repositório, agentes personalizados permite a criação de agentes totalmente especializados, com expertise focada e configurações de ferramentas personalizadas. Esses agentes são projetados para fluxos de trabalho específicos e recorrentes em que a experiência de domínio e o comportamento consistente são cruciais. Agentes personalizados são definidos como arquivos Markdown chamados perfis de agente.

Aqui estão alguns exemplos de agentes personalizados que você pode criar:

•         **Especialista em teste**: um agente configurado com estruturas de teste específicas e focado na cobertura de teste, qualidade do teste e práticas recomendadas de teste. Pode ser limitado a ferramentas de leitura, pesquisa e edição para evitar alterações não intencionais no código de produção, garantindo uma cobertura de teste abrangente.
  

•         **Especialista em documentação**: um agente especializado em criar e manter a documentação do projeto, com profundo conhecimento dos padrões de documentação, guias de estilo e a capacidade de analisar código para gerar documentação precisa da API e guias do usuário.
  

•         **Especialista em Python**: um agente específico da linguagem que entende as convenções do Python, estruturas populares como Django ou Flask e segue os padrões PEP. Ele teria conhecimento especializado de ferramentas do Python, ambientes virtuais e estruturas de teste, como pytest.
  

Por padrão, agentes personalizados herda todas as ferramentas de servidor MCP que foram configuradas no repositório, mas você também pode configurar agentes personalizados para ter acesso apenas a ferramentas específicas.

Você pode usar agentes personalizados em qualquer lugar onde você usa agente de codificação Copilot, inclusive ao atribuir uma questão ou ao solicitar uma tarefa.

Para obter mais informações sobre como criar e configurar agentes personalizados, consulte Criando agentes personalizados para agente de codificação Copilot.

Pré-instalação de dependências no GitHub Copilotambiente

Ao trabalhar em uma tarefa, Copilot tem acesso ao seu próprio ambiente de desenvolvimento efêmero, alimentado por GitHub Actions, onde pode explorar seu código, fazer alterações, executar testes automatizados e linters e muito mais.

Se Copilot for capaz de criar, testar e validar suas alterações em seu próprio ambiente de desenvolvimento, é mais provável que ele produza boas solicitações de pull que podem ser mescladas rapidamente.

Para fazer isso, ele precisará das dependências do projeto. Copilot pode descobrir e instalar essas dependências por meio de um processo de tentativa e erro, mas isso pode ser lento e não confiável, dada a natureza não determinística dos modelos de linguagem de grande escala (LLMs).

Você pode configurar um arquivo copilot-setup-steps.yml para pré-instalar essas dependências antes que o agente comece a trabalhar para que ele possa trabalhar com eficácia rapidamente. Para obter mais informações, consulte Personalizando o ambiente de desenvolvimento para o GitHub Copilot, agente de codificação.