Utilisation de GitHub Copilot pour réduire la dette technique

Présentation

La dette technique s’accumule dans chaque base de code : code en double, tests manquants, dépendances obsolètes et modèles incohérents. Ces problèmes peuvent s’accumuler, car le développement de fonctionnalités est généralement donné une priorité plus élevée. Ce tutoriel explique comment vous pouvez utiliser GitHub Copilot pour résoudre systématiquement la dette technique, sans sacrifier la vélocité des fonctionnalités.

Pour qui ce tutoriel est destiné

Ce tutoriel est conçu pour aider les équipes d’ingénierie et les prospects techniques à réduire la dette technique tout en conservant le rythme auquel de nouvelles fonctionnalités sont fournies. Vous devez disposer de :

Un Copilot abonnement avec accès à Agent Copilot cloud
Access d’administration dans au moins un référentiel
Connaissance du flux de travail de développement de votre équipe

Ce que vous allez faire

À la fin de ce tutoriel, vous avez découvert les points suivants :

L'utilisation de Copilot pour implémenter des correctifs en temps réel
Utilisation de Agent Copilot cloud pour des tâches de nettoyage à grande échelle
Création d’instructions personnalisées pour s’aligner Copilot sur les normes de votre équipe
Mesurer l’impact de Copilot sur votre dette technique

Comprendre le problème de la dette technique

Avant de commencer à réduire la dette technique dans une base de code, vous devez prendre un certain temps pour identifier les types de dettes techniques auxquelles votre équipe fait face le plus souvent.

Les types courants de dette technique sont les suivants :

        **Duplication de code** - La même logique implémentée à plusieurs emplacements

        **Tests manquants** - Fonctionnalités sans couverture de test adéquate

        **Dépendances obsolètes** - Bibliothèques en retard de plusieurs versions par rapport aux versions actuelles

        **Modèles incohérents** - Différentes approches du même problème dans votre codebase

        **Code hérité** - Ancien code qui fonctionne mais ne respecte pas les normes actuelles

Le coût de la dette technique s'accumule au fil du temps.

Les ingénieurs supérieurs consacrent du temps aux mises à jour de routine au lieu de la conception d’architecture
Les révisions de code deviennent plus longues, car les réviseurs débattent des modèles incohérents
Les nouveaux développeurs prennent plus de temps à intégrer en raison d’une organisation de code déroutante
Le risque de déploiement augmente à mesure que les dépendances obsolètes accumulent des vulnérabilités

Utiliser Copilot dans votre IDE pour des correctifs instantanés

La meilleure façon d’éviter l’accumulation de dettes techniques dans votre codebase consiste à l’empêcher d’entrer dans le codebase en premier lieu.

Lorsque vous rencontrez une dette technique pendant le développement, corrigez-la immédiatement à l’aide Copilot de votre IDE.

Flux de travail de refactorisation rapide

Pendant que vous travaillez dans votre IDE, mettez en évidence le code qui a besoin d’amélioration.
Ouvrez Tchat Copilot dans l’IDE.
Demandez Copilot à refactoriser le code. Par exemple:
- 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
Passez en revue les modifications suggérées.
Acceptez les modifications ou demandez-lui Copilot de modifier son approche.
Exécutez vos tests pour vérifier que les modifications fonctionnent correctement.

Exemple : normalisation de la gestion des erreurs

Si vous trouvez une gestion incohérente des erreurs, par exemple :

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

Demandez Copilot à améliorer le code, par exemple :

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 peut suggérer :

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

Remarque

Cette réponse est un exemple. Tchat Copilot les réponses ne sont pas déterministes. Vous pouvez donc obtenir une réponse différente si vous exécutez la même invite sur le même code.

En adoptant l’approche de correctif dans le moment, vous pouvez vous assurer que le code non standard n’est pas ajouté à votre base de code et que vous évitez la création d’un problème de backlog qui ne peut jamais être résolu.

Pour plus d’informations sur l’utilisation Copilot dans votre IDE, consultez Poser des questions à GitHub Copilot dans votre IDE.

Utilisation Agent Copilot cloud pour la refactorisation à grande échelle

Certaines tâches de refactorisation sont trop volumineuses pour s’exécuter alors que tout le monde de l’équipe est occupé à développer de nouvelles fonctionnalités. Dans ce cas, vous pouvez utiliser Agent Copilot cloud pour gérer ces tâches de manière autonome. L'effort humain sera toujours nécessaire, au minimum pour examiner les modifications proposées par Agent Copilot cloud. Toutefois, confier à Copilot la majeure partie du travail peut vous permettre d'effectuer une refactorisation à grande échelle avec beaucoup moins d'impact sur la productivité de votre équipe.

Quand utiliser Agent Copilot cloud

Utilisez Agent Copilot cloud pour les tâches qui :

Toucher de nombreux fichiers dans votre codebase
Exiger des modifications systématiques (comme la suppression d’anciens indicateurs de fonctionnalité)
Besoin de tests prudents, mais sont simples à implémenter
Interrompre le développement des fonctionnalités s’il est effectué manuellement

Voici quelques exemples :

Mises à niveau de cadre qui affectent plus de 50 fichiers
Suppression des indicateurs de fonctionnalité déconseillés
Migration vers un typeScript strict
Mise à jour des versions des dépendances
Normalisation des modèles d’importation

Flux de travail pour Agent Copilot cloud

Créez un GitHub problème décrivant la tâche de refactorisation.

Soyez précis sur ce qui doit changer. Par exemple:

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.

Affectez le problème à l’utilisateur Copilot .
```
       Agent Copilot cloud va effectuer les actions suivantes :
```
- Configurer un environnement de développement
- Ouvrir une pull request brouillon
- Apporter les modifications requises au code
- Exécuter vos tests
- Finaliser la pull request pour examen
- Demander votre revue de la pull request
Passez en revue le pull request comme vous le feriez pour un pull request soumis par un humain.
Laissez des commentaires si des modifications sont nécessaires—Agent Copilot cloud mettra à jour la pull request en fonction de vos retours.
Itérer de cette façon jusqu’à ce que le travail soit terminé correctement.
Approuvez et fusionnez le pull request.

Pour plus d’informations, consultez « Demander à GitHub Copilot de créer un pull request » et « Revue d'une pull request créée par GitHub Copilot ».

Garde-fous de sécurité

          Agent Copilot cloud fonctionne avec des mesures de sécurité intégrées :

Il ne peut pousser que vers ses propres branches copilot/*
Ne peut pas fusionner les pull requests — nécessite votre approbation
Toutes les validations sont journalisées et auditables
Vos protections de branche existantes restent actives
Vérifications CI/CD exécutées avant la fusion d’un code

Création d’instructions personnalisées pour votre équipe

Les instructions personnalisées vous aident à Copilot comprendre les normes et les modèles de codage de votre équipe. Cela garantit que les suggestions correspondent à vos attentes dès le début.

Configuration d’instructions personnalisées

Dans votre référentiel, créez un fichier nommé .github/copilot-instructions.md.
Ajoutez les normes de codage de votre équipe en instructions claires et simples, par exemple à l’aide de listes à puces.
Commitez le fichier dans votre dépôt.

Exemples d’instructions personnalisées

Voici un exemple d’instructions personnalisées efficaces :

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

Pour obtenir des conseils détaillés sur l’écriture d’instructions personnalisées, consultez Ajout d’instructions personnalisées de référentiel pour GitHub Copilot.

Avantages des instructions personnalisées

Avec des directives personnalisées établies :

        Copilot suggère le code suivant vos modèles

Les révisions de code deviennent plus rapides, avec moins de discussions sur les modifications de style
Les nouveaux membres de l’équipe apprennent vos normes par le biais Copilot de suggestions
La cohérence s’améliore dans votre base de code

Exécution d’un programme pilote

Commencez petit pour valider l’impact de Copilot sur votre dette technique avant de le déployer largement.

Semaine 1 : Configurer et établir des lignes de base

Vérifiez que tous les participants pilotes ont Copilot accès avec Agent Copilot cloud activé.
Comptez les éléments de dette technique dans votre backlog :
- Nombre de « dettes technologiques », de « corvées » ou de problèmes étiquetés similaires
- Nombre de dépendances obsolètes
- Nombre de fichiers échouant aux contrôles du linter
Suivez les métriques actuelles :
- Temps moyen entre la création d’une pull request et sa fusion pour les pull requests de refactorisation
- Nombre moyen de cycles de revue par pull request de refactorisation
Créez votre premier fichier .github/copilot-instructions.md avec 3 à 5 de vos normes les plus importantes.

Semaines 2 à 4 : Exécuter le pilote

Sélectionnez 5 à 10 dépôts pour votre pilote.
Choisissez 1 à 2 problèmes spécifiques à résoudre. Par exemple:
- Duplication de code dans une zone particulière
- Tests manquants sur les fichiers fréquemment modifiés
- Dépendances obsolètes
Utilisez Copilot votre IDE pour obtenir des correctifs rapides lorsque vous rencontrez des problèmes.
Affecter des tâches de nettoyage plus volumineuses à Agent Copilot cloud.
Passez en revue attentivement toutes les pull requests générées par Copilot.
Fournissez des commentaires sur les suggestions pour vous aider Copilot à découvrir vos préférences.

Semaine 5 : Évaluer les résultats

Après le pilote, mesurez vos résultats :

À quelle vitesse les pull requests de refactorisation sont-elles fusionnées désormais ?
Combien de tours de révision ont-ils besoin maintenant ?
Quels types de suggestions de modification de code, faites par Agent Copilot cloud dans les pull requests, les développeurs acceptent-ils le plus souvent ?
Quelles suggestions nécessitaient la plus grande révision ?
Vos mesures techniques de dette s’améliorent-elles ?
- Les avertissements du linter diminuent-ils ?
- La couverture des tests augmente ?
- Les versions des dépendances sont-elles plus à jour ?

Mettez à jour vos instructions personnalisées en fonction de ce que vous avez appris sur les conseils qui ont aidé Copilot le plus.

Mesure du succès

Suivez des métriques spécifiques pour comprendre l’impact de Copilot votre dette technique.

Métriques de vélocité

Surveillez l’impact Copilot sur la vitesse de développement :

Délai de clôture des problèmes de dette technique (cible : 30 à 50% réduction)
Nombre de pull requests de dette technique fusionnées par semaine (objectif : augmentation de 2 à 3 fois)
Nombre moyen de cycles de révision par pull request de refactorisation (évaluer si cela a augmenté ou diminué)

Métriques de qualité

Assurez-vous que la qualité s’améliore en même temps que la vitesse :

Nombre d’avertissements Linter (cette tendance devrait être à la baisse)
Pourcentage de couverture des tests (cette tendance devrait augmenter)
Nombre d’incidents de production liés au code refactorisé (évaluer si cette modification a été modifiée)

Satisfaction de l’ingénieur

Interrogez régulièrement votre équipe :

Les ingénieurs consacrent-ils moins de temps à la maintenance de routine ?
Les révisions de code se concentrent-elles davantage sur l’architecture et moins sur le style ?
L’intégration est-elle plus rapide pour les nouveaux membres de l’équipe ?

Résolution des problèmes

          Copilot suggère des modifications incorrectes

Si Copilot suggère constamment du code qui ne correspond pas à vos besoins :

Passer en revue vos instructions personnalisées : elles peuvent être trop vagues ou contradictoires
Fournir un contexte plus spécifique dans vos invites
Ajouter des exemples de code approprié à vos instructions personnalisées
Laissez des commentaires détaillés dans les révisions de pull request pour permettre à Agent Copilot cloud de résoudre les problèmes.

Les demandes de tirage sont trop volumineuses pour passer en revue

Si Agent Copilot cloud crée des requêtes de tirage qui sont difficiles à réviser :

Interrompre les tâches volumineuses en problèmes plus petits et ciblés
Demander Agent Copilot cloud à gérer un fichier ou un répertoire à la fois
Utiliser des descriptions de problèmes plus spécifiques

Modifications des tests d’arrêt

Si la refactorisation introduit des échecs de test :

Vérifiez que votre suite de tests s’exécute de manière fiable avant d’utiliser Agent Copilot cloud
Examiner attentivement les Copilot modifications avant la fusion
Demandez à Copilot de mettre à jour les tests avec les modifications de code

L’adoption par l’équipe est lente

Si votre équipe n’utilise pas Copilot pour gérer la dette technique :

Partager des témoignages de réussite des premiers utilisateurs
Démontrer les économies de temps dans les réunions d’équipe
Commencez par les éléments de dette techniques les plus ennuyeux
Faire de la création d'instructions personnalisées une activité d'équipe

Conclusion

Dans ce tutoriel, vous avez appris à utiliser Copilot pour réduire systématiquement la dette technique. Vous savez maintenant comment :

Corriger la dette technique immédiatement à l’aide Copilot de votre IDE
Affecter des tâches de refactorisation volumineuses à Agent Copilot cloud
Créer des instructions personnalisées qui s’alignent Copilot sur les normes de votre équipe
Exécuter un programme pilote pour valider l’approche
Mesurer l’impact de Copilot sur la dette technique

En automatisant les tâches de refactorisation et de maintenance de routine, Copilot vous permet de vous concentrer sur l’architecture, le développement de fonctionnalités et d’autres travaux à valeur élevée.

Enquête rapide

Après avoir lu ce tutoriel, êtes-vous confiant que vous pouvez utiliser Copilot pour réduire la dette technique dans une base de code ?

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

Étapes suivantes

        **Développez votre pilote : Déployez-le** dans d’autres référentiels en fonction de vos résultats pilotes.

        **Automatiser les mises à jour des dépendances : créez** des problèmes récurrents pour Agent Copilot cloud gérer les mises à jour des dépendances.

        **Créez une file d’attente de refactorisation** : Étiquetez les problèmes dans votre backlog comme étant adaptés pour Copilot, puis assignez régulièrement un lot de ces éléments à Copilot pour les retravailler.

        **Partagez les meilleures pratiques** : documentez les invites réussies et les instructions personnalisées pour votre équipe.

Lectures complémentaires

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

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

        [Comment utiliser GitHub Copilot dans votre IDE : conseils, astuces et bonnes pratiques](https://github.blog/developer-skills/github/how-to-use-github-copilot-in-your-ide-tips-tricks-and-best-practices/) dans le GitHub blog

        [5 façons d’intégrer GitHub Agent Copilot cloud à votre flux de travail](https://github.blog/ai-and-ml/github-copilot/5-ways-to-integrate-github-copilot-coding-agent-into-your-workflow/) dans le GitHub blog

Utilisation de GitHub Copilot pour réduire la dette technique

Dans cet article