Procedimientos recomendados para usar GitHub Copilot para trabajar en tareas

Obtenga información sobre cómo obtener los mejores resultados de Agente de programación Copilot.

¿Quién puede utilizar esta característica?

Agente de programación Copilot está disponible con los planes GitHub Copilot Pro, GitHub Copilot Pro+, GitHub Copilot para empresas y GitHub Copilot para grandes empresas. El agente está disponible en todos los repositorios almacenados en GitHub, excepto si se ha deshabilitado explícitamente y los repositorios que pertenecen a cuentas de usuario administradas.
Sign up for Copilot

En este artículo

Nota:

Para obtener una introducción a Agente de programación Copilot, consulte Acerca del agente de codificación de GitHub Copilot.

Asegurarte de que las propuestas tienen un ámbito correcto

          GitHub Copilot proporciona mejores resultados cuando se asignan tareas claras y bien definidas. Una tarea ideal incluye:
  • Una descripción clara del problema que se va a resolver o del trabajo necesario.
  • Criterios de aceptación completos sobre el aspecto de una buena solución (por ejemplo, ¿debería haber pruebas unitarias?).
  • Instrucciones sobre qué archivos deben cambiarse.

Sugerencia

          Agente de programación Copilot tiene la capacidad de buscar en el código base, incluida la búsqueda de código semántico, que ayuda a encontrar código relevante en función del significado en lugar de simplemente coincidencias exactas de texto. Incluso si no especifica rutas de acceso exactas de archivo en una tarea, el agente a menudo puede detectar el código correcto por sí mismo.

Si asigna una tarea a Copilot mediante la asignación de un problema, resulta útil pensar en el problema que asigna a Copilot como un estímulo o propuesta. Tenga en cuenta si es probable que la descripción del problema funcione como una solicitud de IA y habilitará Copilot para realizar los cambios de código necesarios.

Elegir el tipo correcto de tareas para asignar a Copilot

A medida que trabaje con Copilot, obtendrá una idea de los tipos de tareas en los que es más adecuado trabajar. Inicialmente, es posible que quiera empezar proporcionando Copilot tareas más sencillas para ver cómo funciona como un agente de codificación. Por ejemplo, puede empezar pidiendo Copilot que corrija errores, modifique las características de la interfaz de usuario, mejore la cobertura de pruebas, actualice la documentación, mejore la accesibilidad o solucione la deuda técnica.

Los problemas que puede decidir trabajar por sí mismo, en lugar de asignarlos a Copilot, incluyen:

  •         **Tareas complejas y de ámbito general**
    • Problemas de refactorización de contexto y de ámbito amplio que requieren conocimientos y pruebas entre repositorios
    • Problemas complejos que requieren comprender las dependencias y el código heredado
    • Tareas que requieren conocimientos profundos de dominio
    • Tareas que implican una lógica de negocios sustancial
    • Cambios grandes en un código base que requiere coherencia de diseño
  •         **Tareas confidenciales y críticas**
    • Problemas críticos para la producción
    • Tareas relacionadas con la seguridad, información de identificación personal, repercusiones en la autenticación
    • Respuesta a incidentes
  •         **Tareas ambiguas**
    • Tareas que carecen de definición clara: tareas con requisitos ambiguos, tareas abiertas, tareas que requieren trabajar con incertidumbre para encontrar una solución
  •         **Tareas de aprendizaje**
    • Tareas en las que el desarrollador quiere aprender para lograr una mejor comprensión

Uso de comentarios para iterar en una solicitud de incorporación de cambios

Trabajar con Copilot en un pull request es igual que trabajar con un desarrollador humano: es común que el pull request necesite más trabajo antes de poder fusionarlo. El proceso para llevar la solicitud de incorporación de cambios a un estado combinable es exactamente el mismo tanto si la solicita Copilot como si la solicita un usuario.

Además, puede:

  • Mencione @copilot en comentarios sobre la solicitud de incorporación de cambios, explicando lo que cree que es incorrecto o podría mejorarse y Copilot insertará confirmaciones directamente en la rama de la solicitud de incorporación de cambios.
  • Pida a Copilot que resuelva los conflictos de combinación en el pull request. Consulta Solicitar a GitHub Copilot que realice cambios en un pull request existente..
  • Trabaje en la rama de funciones usted mismo y empuje los cambios al pull request.

Después de que un usuario con acceso de escritura mencione @copilot en un comentario, Copilot comenzará a realizar los cambios necesarios y actualizará la solicitud de 'pull request' cuando haya terminado. Dado que el sistema comienza a examinar los comentarios tan pronto como se envían, si es probable que realice varios comentarios en un pull request, es mejor agruparlos haciendo clic en Iniciar una revisión, en vez de hacer clic en Agregar comentario único. Después, puede enviar todos sus comentarios a la vez, desencadenando Copilot para trabajar en toda la revisión, en lugar de trabajar en comentarios individuales por separado.

Nota:

Copilot solo responde a los comentarios de personas que tienen acceso de escritura al repositorio.

A medida que Copilot realiza cambios en la solicitud de incorporación de cambios, mantendrá el título y el cuerpo actualizados para reflejar los cambios actuales.

Adición de instrucciones personalizadas al repositorio

Al agregar instrucciones personalizadas a su repositorio, puede guiar a Copilot sobre cómo entender su proyecto y cómo construir, probar y validar sus cambios.

Si Copilot es capaz de compilar, probar y validar sus cambios en su propio entorno de desarrollo, es más probable que genere buenas solicitudes de incorporación de cambios que se pueden combinar rápidamente.

          Agente de programación Copilot admite varios tipos diferentes de archivos de instrucciones personalizadas:
  • /.github/copilot-instructions.md
  • /.github/instructions/**/*.instructions.md
  • **/AGENTS.md
  • /CLAUDE.md
  • /GEMINI.md

Para obtener más información, vea Agregar instrucciones personalizadas del repositorio para GitHub Copilot.

Instrucciones para todo el repositorio

Para agregar instrucciones que se aplican a todas las tareas asignadas a Copilot en el repositorio, cree un .github/copilot-instructions.md archivo en la raíz del repositorio. Este archivo debe contener información sobre el proyecto, como cómo compilarlo y probarlo, y cualquier estándar o convenciones de codificación que desee Copilot seguir. Tenga en cuenta que las instrucciones también se aplicarán a chat de Copilot y revisión de código Copilot.

La primera vez que pida Copilot que cree una solicitud de incorporación de cambios en un repositorio determinado, Copilot dejará un comentario con un vínculo para generar automáticamente instrucciones personalizadas. También puede pedir que Copilot genere instrucciones personalizadas para usted en cualquier momento mediante nuestro aviso recomendado. Consulta Agregar instrucciones personalizadas del repositorio para GitHub Copilot.

También puede escribir sus propias instrucciones personalizadas cuando quiera. Este es un ejemplo de un archivo copilot-instructions.md efectivo:

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

Instrucciones específicas de la ruta de acceso

Para agregar instrucciones que se aplican a tipos específicos de archivos en los que Copilot trabajará, como pruebas unitarias o componentes de React, cree uno o más archivos .github/instructions/**/*.instructions.md en su repositorio. En estos archivos, incluya información sobre los tipos de archivo, como cómo compilarlos y probarlos, así como las convenciones o estándares de codificación que desee Copilot seguir.

Con el patrón global en el archivo de instrucciones, puedes especificar los tipos de archivo a los que se deben aplicar. Por ejemplo, para crear instrucciones para las pruebas de Playwright, podría crear un archivo de instrucciones denominado .github/instructions/playwright-tests.instructions.md con el siguiente contenido:

---
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

Instrucciones personalizadas para toda la organización

          Agente de programación Copilot aprovecha las instrucciones personalizadas de su organización como parte de su trabajo. 
          Agente de programación Copilot primero da prioridad a las instrucciones personalizadas para todo el repositorio. Para obtener más información sobre cómo configurar instrucciones personalizadas de la organización, consulte [AUTOTITLE](/copilot/how-tos/configure-custom-instructions/add-organization-instructions).

Uso del protocolo de contexto de modelo (MCP)

Puede ampliar las funcionalidades de Agente de programación Copilot mediante MCP. Esto permite Agente de programación Copilot usar herramientas proporcionadas por servidores MCP locales y remotos. El GitHub servidor MCP y el servidor MCP playwright están habilitados de forma predeterminada. Para obtener más información, vea Extensión del agente de codificación de GitHub Copilot con el protocolo de contexto de modelo (MCP).

Creación agentes personalizados

Aunque las instrucciones personalizadas ayudan a guiar Copilotel comportamiento general de su repositorio, agentes personalizados cree agentes completamente especializados con conocimientos centrados y configuraciones de herramientas adaptadas. Estos agentes están diseñados para flujos de trabajo específicos y periódicos en los que la experiencia en el dominio y el comportamiento coherente son cruciales. Agentes personalizados se definen como archivos Markdown denominados perfiles de agente.

Estos son algunos ejemplos de agentes personalizados que puede crear:

  •         **Especialista en pruebas**: un agente configurado con marcos de pruebas específicos y centrado en la cobertura de pruebas, la calidad de las pruebas y los procedimientos recomendados de pruebas. Es posible que se limite a leer, buscar y editar herramientas para evitar cambios no deseados en el código de producción, a la vez que garantiza una cobertura completa de pruebas.

  •         **Experto en documentación**: agente especializado en la creación y mantenimiento de la documentación del proyecto, con conocimientos profundos sobre los estándares de documentación, las guías de estilo y la capacidad de analizar código para generar documentación de API precisa y guías de usuario.

  •         **Especialista en Python**: un agente específico del lenguaje que comprende las convenciones de Python, marcos populares como Django o Flask, y sigue los estándares pep. Tendría conocimientos especializados sobre herramientas de Python, entornos virtuales y marcos de pruebas como pytest.

De forma predeterminada, agentes personalizados herede las herramientas de servidor MCP que se han configurado en el repositorio, pero también puede configurar agentes personalizados para que solo tenga acceso a herramientas específicas.

Puede usar agentes personalizados en cualquier lugar en el que use Agente de programación Copilot, incluyendo al asignar un problema o iniciar una tarea.

Para obtener más información sobre cómo crear y configurar agentes personalizados, vea Creación de agentes personalizados para Agente de programación Copilot.

Preinstalación de dependencias en el entorno de GitHub Copilot.

Mientras trabaja en una tarea, Copilot tiene acceso a su propio entorno de desarrollo temporal, impulsado por tecnología de GitHub Actions, donde puede explorar su código, realizar cambios, ejecutar pruebas automatizadas y linters, etc.

Si Copilot es capaz de compilar, probar y validar sus cambios en su propio entorno de desarrollo, es más probable que genere buenas solicitudes de incorporación de cambios que se pueden combinar rápidamente.

Para hacer eso, necesitará las dependencias de tu proyecto. Copilot puede detectar e instalar estas dependencias a través de un proceso de prueba y error, pero esto puede ser lento y poco confiable, dada la naturaleza no determinista de los modelos de lenguaje grandes (LLM).

Puedes configurar un archivo copilot-setup-steps.yml para preinstalar estas dependencias antes de que el agente empiece a funcionar para que pueda empezar a funcionar inmediatamente. Para obtener más información, vea Personalización del entorno de desarrollo para el agente de codificación GitHub Copilot.