Uso de GitHub Copilot para reducir la deuda técnica

Introducción

La deuda técnica se acumula en cada código base: código duplicado, pruebas que faltan, dependencias obsoletas y patrones incoherentes. Estos problemas se pueden acumular porque el desarrollo de características suele tener una prioridad más alta. En este tutorial se explica cómo puede usar GitHub Copilot para abordar sistemáticamente la deuda técnica sin sacrificar la velocidad de las características.

Para quién es este tutorial

Este tutorial está diseñado para ayudar a los equipos de ingeniería y a los líderes técnicos a reducir la deuda técnica a la vez que se mantiene el ritmo al que se entregan nuevas características. Debería tener:

Una suscripción a Copilot con acceso a Agente de programación Copilot
Acceso de administrador a al menos un repositorio
Familiaridad con el flujo de trabajo de desarrollo de su equipo

Podrá:

Al final de este tutorial, habrá aprendido lo siguiente:

Uso de Copilot para implementar correcciones en el momento
Aprovechamiento de Agente de programación Copilot para tareas de limpieza a gran escala
Creación de instrucciones personalizadas para alinear Copilot con los estándares de tu equipo
Medición del impacto de Copilot sobre la deuda técnica

Descripción del problema de la deuda técnica

Antes de empezar a reducir la deuda técnica en un código base, debe tardar algún tiempo en identificar los tipos de deuda técnica a las que se enfrenta el equipo con más frecuencia.

Entre los tipos comunes de deuda técnica se incluyen:

        **Duplicación de código** : la misma lógica implementada en varios lugares

        **Pruebas que faltan** : características sin cobertura de pruebas adecuada

        **Dependencias obsoletas** - bibliotecas que están varias versiones por detrás de las lanzadas recientemente

        **Patrones incoherentes:** diferentes enfoques para el mismo problema en el código base

        **Código heredado** : código antiguo que funciona, pero que no sigue los estándares actuales

El costo de la deuda técnica se acumula a lo largo del tiempo.

Los ingenieros sénior pasan tiempo en actualizaciones rutinarias en lugar del diseño de arquitectura
Las revisiones de código se vuelven más largas a medida que los revisores debaten patrones incoherentes
Los nuevos desarrolladores tardan más tiempo en incorporarse debido a una organización de código confusa
El riesgo de implementación aumenta a medida que las dependencias obsoletas acumulan vulnerabilidades

Usar Copilot en su IDE para correcciones en el momento

La mejor manera de evitar la acumulación de deudas técnicas en el código base es evitar que entre en el código base en primer lugar.

Cuando encuentres deuda técnica durante el desarrollo, corrígela inmediatamente usando Copilot en tu IDE.

Flujo de trabajo de refactorización rápida

Mientras trabaja en el IDE, resalte el código que necesita mejora.
Abra chat de Copilot en el IDE.
Pida a Copilot que refactorice el código. Por ejemplo:
- Extract this into a reusable helper and add error handling
- Standardize this logging format to match our pattern
- Add null checks for all optional parameters
- Replace this deprecated API call with the current version
Revise los cambios sugeridos.
Acepte los cambios o solicite a Copilot que modifique su estrategia.
Ejecute las pruebas para comprobar que los cambios funcionan correctamente.

Ejemplo: Estandarización del control de errores

Si encuentra un control de errores incoherente, por ejemplo:

// Highlight this code
try {
  await fetchData();
} catch (e) {
  console.log(e);
}

Pídale a Copilot que mejore el código, por ejemplo:

Copilot prompt

Refactor this to use structured logging and proper error handling

// Highlight this code
try {
  await fetchData();
} catch (e) {
  console.log(e);
}

Refactor this to use structured logging and proper error handling

Refactor this to use structured logging and proper error handling

Copilot podría sugerir:

try {
  await fetchData();
} catch (error) {
  logger.error('Failed to fetch data', {
    error: error.message,
    stack: error.stack,
    timestamp: new Date().toISOString()
  });
  throw error;
}

Nota:

Esta respuesta es un ejemplo. Las respuestas de chat de Copilot no son deterministas, por lo que podría obtener una respuesta diferente si ejecuta la misma solicitud con el mismo código.

Al adoptar el enfoque de corrección en el momento, se ayuda a asegurarse de que el código de subestándar no se agrega al código base y evita la creación de un problema de trabajo pendiente que nunca se pueda solucionar.

Para obtener más información sobre el uso de Copilot en el IDE, consulte Hacer preguntas a GitHub Copilot en tu IDE.

Utilización de Agente de programación Copilot para la refactorización a gran escala

Algunas tareas de refactorización son demasiado grandes para completarse mientras todos los miembros del equipo están ocupados desarrollando nuevas características. En esta situación, puede usar Agente de programación Copilot para gestionar estas tareas de forma autónoma. El esfuerzo humano seguirá siendo necesario (como mínimo para revisar los cambios que Agente de programación Copilot propone), pero que Copilot realice la mayor parte del trabajo le permitirá llevar a cabo una refactorización a gran escala afectando mucho menos la productividad de su equipo.

Cuándo utilizar Agente de programación Copilot

Utilice Agente de programación Copilot para tareas que:

Modificación de varios archivos en la base de código
Requerir cambios sistemáticos (como quitar marcas de características antiguas)
Necesita pruebas cuidadosas, pero son sencillas de implementar
Interrumpiría el desarrollo de características si se realiza manualmente

Algunos ejemplos son:

Actualizaciones del marco que afectan a más de 50 archivos
Eliminación de banderas de características en desuso
Migración a TypeScript estricto
Actualización de versiones de dependencia
Estandarización de patrones de importación

Flujo de trabajo para Agente de programación Copilot

Cree una incidencia de GitHub que describa la tarea de refactorización.

Sea específico sobre lo que necesita cambiar. Por ejemplo:

Remove all feature flags marked for cleanup in Q2.

These flags are:
- `enable_new_dashboard`
- `beta_export_feature`
- `experimental_search`

All three flags are enabled by default in production.

Remove the flag checks and keep the "enabled" code path.

Asigne el problema al usuario de Copilot .
Agente de programación Copilot realizará lo siguiente:
- Configuración de un entorno de desarrollo
- Apertura de un borrador de solicitud de incorporación de cambios
- Realice los cambios necesarios en el código.
- Ejecuta tus pruebas
- Finalización de la solicitud de incorporación de cambios para revisión
- Solicitud de revisión de la solicitud de incorporación de cambios
Revise la solicitud de incorporación de cambios como haría con una solicitud de incorporación de cambios generada por un usuario.
Deje comentarios si se necesitan cambios:Agente de programación Copilot actualizará la solicitud de incorporación de cambios en función de sus comentarios.
Itera de esta manera hasta que el trabajo se complete correctamente.
Apruebe y combine la solicitud de incorporación de cambios.

Para más información, consulta Pedir a GitHub Copilot que cree una solicitud de incorporación de cambios y Revisión de una solicitud de incorporación de cambios creada por GitHub Copilot.

Barreras de protección de seguridad

Agente de programación Copilot funciona con medidas de seguridad integradas:

Solo puede insertar en sus propias copilot/* ramas
No se pueden combinar solicitudes de pull request: requiere tu aprobación.
Todas las confirmaciones se registran y auditan
Las protecciones de rama existentes permanecen activas
Las comprobaciones de CI/CD se ejecutan antes de combinar cualquier código

Creación de instrucciones personalizadas para el equipo

Las instrucciones personalizadas ayudan a Copilot a comprender los estándares y patrones de codificación de tu equipo. Esto garantiza que las sugerencias coincidan con sus expectativas desde el principio.

Configuración de instrucciones personalizadas

En el repositorio, cree un archivo denominado .github/copilot-instructions.md.
Agregue los estándares de codificación del equipo en instrucciones claras y sencillas, por ejemplo, mediante listas con viñetas.
Confirme el archivo en el repositorio.

Instrucciones personalizadas de ejemplo

Este es un ejemplo de instrucciones personalizadas eficaces:

## Our Standards

- Use structured logging, not console.log
- Sanitize user input before database queries
- Check for null/undefined on all optional parameters
- Keep functions under 50 lines (extract helpers if needed)
- Every public function needs a test
- Flag any loops that might trigger N+1 queries

## Error Handling

- Always use try-catch blocks for async operations
- Log errors with context (user ID, request ID, timestamp)
- Never swallow errors silently
- Return appropriate HTTP status codes

## Testing Requirements

- Unit tests for all business logic
- Integration tests for API endpoints
- Mock external services in tests
- Test both success and failure paths

Para obtener instrucciones detalladas sobre cómo escribir instrucciones personalizadas, consulte Agregar instrucciones personalizadas del repositorio para GitHub Copilot.

Ventajas de las instrucciones personalizadas

Con instrucciones personalizadas establecidas:

Copilot sugiere código siguiendo sus patrones
Las revisiones de código se vuelven más rápidas, con menos discusiones sobre los cambios de estilo
Los nuevos miembros del equipo aprenden sus estándares a través de las sugerencias de Copilot
La coherencia mejora a lo largo del código base

Ejecución de un programa piloto

Empiece poco a poco para validar el impacto de Copilot en su deuda técnica antes de implementarlo ampliamente.

Semana 1: Configurar y establecer líneas base

Asegúrese de que todos los participantes piloto tengan acceso a Copilot con Agente de programación Copilot habilitado.
Cuente los elementos de deuda técnica en el trabajo pendiente:
- Número de "deuda técnica", "tarea rutinaria" o problemas etiquetados similares
- Número de dependencias obsoletas
- Número de archivos que no pasan las comprobaciones del linter
Realizar un seguimiento de las métricas actuales:
- Tiempo promedio desde la creación hasta la combinación de la solicitud de incorporación de cambios de refactorización
- Número promedio de rondas de revisión por solicitud de incorporación de cambios de refactorización.
Cree su primer archivo .github/copilot-instructions.md con 3–5 de sus estándares más importantes.

Semanas 2–4: Llevar a cabo el proyecto piloto

Seleccione entre 5 y 10 repositorios para su piloto.
Elija 1–2 problemas específicos para solucionar. Por ejemplo:
- Duplicación de código en un área determinada
- Faltan pruebas en archivos modificados con frecuencia
- Dependencias obsoletas
Usa Copilot en tu IDE para obtener correcciones rápidas cuando encuentres problemas.
Asigne tareas de limpieza más grandes a Agente de programación Copilot.
Revise cuidadosamente todas las solicitudes de incorporación de cambios generadas por Copilot.
Dé sus comentarios sobre las sugerencias para ayudar a Copilot a aprender sus preferencias.

Semana 5: Evaluar resultados

Después del piloto, mida los resultados:

¿Cuánto más rápido se combinan las solicitudes de incorporación de cambios de refactorización?
¿Cuántas rondas de revisión requieren ahora?
¿Qué tipos de sugerencias de cambio de código, realizadas por Agente de programación Copilot en las solicitudes de incorporación de cambios, ¿los desarrolladores aceptaron con más frecuencia?
¿Qué sugerencias necesitaban la mayoría de las revisiones?
¿Mejoran las métricas de deuda técnica?
- ¿Se reducen las advertencias de linter?
- ¿Se está incrementando la cobertura de pruebas?
- ¿Versiones de dependencia más actuales?

Actualice las instrucciones personalizadas según lo que ha aprendido sobre qué guía ha ayudado más a Copilot.

Medición del éxito

Realice un seguimiento de métricas específicas para comprender el impacto de Copilot en la deuda técnica.

Métricas de velocidad

Supervise cómo Copilot afecta a la velocidad de desarrollo:

Tiempo para cerrar los problemas de deuda técnica (objetivo: 30–50% reducción)
Número de solicitudes de incorporación de cambios de deuda técnica combinadas por semana (objetivo: aumento de 2 a 3 veces)
Número medio de ciclos de revisión por pull request de refactorización (evalúe si este número ha aumentado o disminuido)

Métricas de calidad

Asegúrese de que la calidad mejora junto con la velocidad:

Recuento de advertencias de Linter (este número debería disminuir)
Porcentaje de cobertura de pruebas (debería mostrar una tendencia ascendente)
Número de incidentes de producción relacionados con el código refactorizado (evalúe si esto ha cambiado)

Satisfacción del ingeniero

Encuesta periódicamente a tu equipo:

¿Los ingenieros pasan menos tiempo en el mantenimiento rutinario?
¿Las revisiones de código se centran más en la arquitectura y menos en el estilo?
¿La incorporación es más rápida para los nuevos miembros del equipo?

Solución de problemas

Copilot sugiere modificaciones incorrectas

Si Copilot sugiere consistentemente código que no coincide con sus necesidades:

Revise sus instrucciones personalizadas: pueden ser demasiado imprecisas o confusas.
Proporcionar contexto más específico en las solicitudes
Adición de ejemplos de código correcto a las instrucciones personalizadas
Deje comentarios detallados en las revisiones de las solicitudes de incorporación de cambios para que Agente de programación Copilot pueda corregir los problemas.

Las solicitudes de incorporación de cambios son demasiado grandes para ser revisadas

Si Agente de programación Copilot crea solicitudes de incorporación de cambios que son difíciles de revisar:

Dividir tareas grandes en problemas más pequeños y centrados
Pida a Agente de programación Copilot que maneje un archivo o directorio a la vez.
Uso de descripciones de problemas más específicas

Cambios en las pruebas de interrupción

Si la refactorización presenta errores de prueba:

Asegúrese de que el conjunto de pruebas se ejecuta de forma fiable antes de usar Agente de programación Copilot
Revise los cambios de Copilot cuidadosamente antes de fusionar
Pida a Copilot que actualice las pruebas junto con los cambios de código.

La adopción del equipo es lenta

Si su equipo no usa Copilot para la deuda técnica:

Compartir historias de éxito de usuarios pioneros
Demostrar el ahorro de tiempo en las reuniones de equipo
Comience con los artículos de deuda técnica más molestos
Haz que la creación de instrucciones personalizadas sea una actividad en equipo

Conclusión

En este tutorial, aprendiste a usar Copilot para disminuir de manera sistemática la deuda técnica. Ahora sabe cómo:

Corrige la deuda técnica con rapidez usando Copilot en tu IDE
Asignación de tareas de refactorización grandes a Agente de programación Copilot
Cree instrucciones personalizadas que alineen Copilot con los estándares del equipo
Ejecución de un programa piloto para validar el enfoque
Mide el impacto de Copilot en la deuda técnica

Al automatizar tareas rutinarias de refactorización y mantenimiento, Copilot le libera para centrarse en la arquitectura, el desarrollo de características y otro trabajo de alto valor.

Encuesta rápida

Después de leer este tutorial, ¿se siente seguro de que puede usar Copilot para reducir la deuda técnica en un código base?

          <a href="https://docs.github.io/success-test/yes.html" target="_blank" class="btn btn-outline mt-3 mr-3 no-underline">
          <span>Yes</span></a><a href="https://docs.github.io/success-test/no.html" target="_blank" class="btn btn-outline mt-3 mr-3 no-underline"><span>No</span></a>

Pasos siguientes

        **Amplíe su prueba piloto**: realice la implementación en más repositorios en función de los resultados de la prueba piloto.

        **Automatizar las actualizaciones de dependencias**: genere incidencias recurrentes para Agente de programación Copilot para gestionar las actualizaciones de dependencias.

        **Cree una cola de refactorización**: etiquete los problemas en su trabajo pendiente como adecuados para Copilot y, a continuación, asigne regularmente un lote de estos a Copilot para trabajar.

        **Compartir buenas prácticas**: documente indicaciones exitosas e instrucciones personalizadas para su equipo.

Lectura adicional

        [AUTOTITLE](/copilot/using-github-copilot/coding-agent)

        [AUTOTITLE](/copilot/tutorials/refactoring-code-with-github-copilot)

        [Cómo usar GitHub Copilot en el IDE: sugerencias, trucos y procedimientos recomendados](https://github.blog/developer-skills/github/how-to-use-github-copilot-in-your-ide-tips-tricks-and-best-practices/) en el blog GitHub

        [5 formas de integrar el agente de codificación de GitHub Copilot en tu flujo de trabajo](https://github.blog/ai-and-ml/github-copilot/5-ways-to-integrate-github-copilot-coding-agent-into-your-workflow/) en el blog GitHub

Uso de GitHub Copilot para reducir la deuda técnica

En este artículo