Travailler à la modernisation avec GitHub Copilot

Cet article explique comment communiquer avec l’agent de modernisation GitHub Copilot, lui enseigner vos préférences, corriger les erreurs, examiner son travail et gérer les mises à niveau entre plusieurs sessions.

GitHub Copilot modernisation est un collaborateur interactif qui pose des questions, propose des stratégies, s’adapte à vos commentaires et apprend de vos préférences au fil du temps. Pour obtenir les meilleurs résultats, fournissez du contexte à l’agent. Plus qu'il en sait sur vos objectifs, contraintes et préférences, mieux il fonctionne.

❌ Vague — the agent has to guess
"Upgrade my project"

✅ Specific — the agent knows exactly what you need
"Upgrade the WebAPI project to .NET 10. We need to keep backward
compatibility with our existing REST clients, and we can't change the
public API surface."

Commencer une conversation

1. Ouvrez Copilot Chat dans VS Code, Visual Studio ou Copilot CLI.
2. Sélectionnez l’agent de modernisation GitHub Copilot pour .NET dans le sélecteur d’agent, ou tapez la mention d’agent appropriée pour votre environnement : @modernize-dotnet dans VS Code et Copilot CLI, ou @Modernize dans Visual Studio.
3. Décrivez ce que vous souhaitez accomplir en langage naturel.

Que dire

Le langage naturel fonctionne. Essayez ces exemples :

Que se passe-t-il ensuite

Lorsque vous démarrez une conversation, l’agent vérifie le travail de mise à niveau existant dans votre espace de travail :

• S’il n’y a pas de travail existant, l’agent démarre à nouveau, généralement à partir d’une évaluation de votre solution.
• S’il existe des travaux en cours, l’agent récupère l’emplacement où vous vous êtes arrêté et affiche l’état actuel, par exemple « 3 des 8 tâches terminées ».

Choisir un mode de flux

L'agent prend en charge deux modes de flux qui contrôlent la fréquence des pauses de l'agent pour recevoir vos instructions.

Mode automatique

En mode automatique, l’agent fonctionne à travers les étapes (évaluation, planification, exécution) sans suspendre l’approbation à chaque limite. L’agent s’arrête toujours en cas de véritables blocages ou quand il a besoin d’une décision que vous seul pouvez prendre.

Idéal pour les utilisateurs expérimentés, les mises à niveau simples et les petites solutions.

Mode guidé

En mode guidé, l’agent s’interrompt à chaque limite de phase pour votre révision :

• Après l’évaluation, avant de créer le plan.
• Après la planification, avant d’exécuter des tâches.
• Avant les répartitions de tâches complexes.
• À des points de décision clés où plusieurs approches valides existent.

Idéal pour les utilisateurs de première fois, les solutions complexes et quand vous souhaitez apprendre le processus.

Changer de mode en cours de session

Basculer librement entre les modes à tout moment :

Enseigner à l’agent

L’agent apprend de vous. L’agent enregistre vos corrections, préférences et instructions dans scenario-instructions.md dans le dossier d’état de mise à niveau. Ces préférences persistent entre les sessions.

Corriger les erreurs

Lorsque l’agent prend une décision avec laquelle vous n’êtes pas d’accord, indiquez à l’agent :

You: "Actually, don't use Newtonsoft.Json — we're standardizing on System.Text.Json."
Agent: "Got it. I'll use System.Text.Json for all serialization going forward.
        I've saved this as a preference."

L’agent met à jour scenario-instructions.md et ne fera plus le même choix, même dans une prochaine session.

Définir les préférences

Indiquez de manière proactive à l’agent comment vous aimez les opérations effectuées :

You: "Always use bottom-up strategy for this solution — upgrade leaf projects first."
Agent: "Noted. I'll use a bottom-up upgrade strategy, starting with projects that
        have no internal dependencies and working up to the top-level projects."

Donner des instructions spécifiques à la tâche

Parfois, une préférence s’applique uniquement à une tâche spécifique :

You: "For this task, skip the test validation — the tests are broken for a known
      reason and we'll fix them separately."
Agent: "Understood. I'll skip test validation for this task only."

Ce que l’agent enregistre

Le scenario-instructions.md fichier est organisé en sections claires :

Effectuer des corrections en cours de session

L’agent gère correctement les interruptions et ne perd pas la trace de l’endroit où il est ou de ce qu’il faisait.

Suspendre et réviser

You: "Wait, stop — let me review that change first."
Agent: "Here's what I was about to do: [describes planned changes].
        Would you like me to proceed, or adjust the approach?"

Rediriger

You: "Actually, let's do Project B before Project A — it has fewer dependencies."
Agent: "Good call. I'll reorder the tasks and start with Project B."

Annuler

You: "That last change broke the build. Can we revert it?"
Agent: "I'll revert the last commit (abc1234: 'Migrate auth middleware').
        Reverting now."

Vous pouvez également annuler les commits vous-même à l’aide des commandes Git standard. L’agent écrit des messages de validation clairs et descriptifs afin de savoir exactement ce que chaque validation a changé.

Poser des questions au milieu du flux

Poser des questions ne déraille pas le flux de travail :

You: "Why did you choose to migrate the data layer before the API controllers?"
Agent: "The API controllers depend on the data layer interfaces. By migrating
        the data layer first, we avoid temporary compilation errors in the
        controllers and can validate each layer independently."

Passer en revue le travail de l’agent

L’agent fournit plusieurs façons d’examiner son travail.

Gestion des sources

L’agent suggère de travailler sur une branche distincte et valide les modifications au fur et à mesure que cela fonctionne. Passez en revue les modifications de l’agent avec les commandes Git standard :

git log --oneline -10
git diff main..<agent-branch>

Fichiers de flux de travail

L’agent gère plusieurs fichiers dans .github/upgrades/{scenarioId}/ montrant une visibilité totale :

Reprendre le travail interrompu

Fermez la conversation ou arrêtez votre IDE. L’agent gère cette situation en toute transparence.

L’agent stocke tous les états dans .github/upgrades/ au sein de votre référentiel. Lorsque vous démarrez une nouvelle conversation, l’agent vérifie l’état actuel et sait immédiatement :

• Quel scénario est actif.
• Quelles tâches sont effectuées, en cours ou en attente.
• Quels artefacts existent (évaluation, plan, fichiers de tâches).
• Si certaines tâches semblent obsolètes (bloquées dans l’état 🔄 depuis une session précédente).

Détection des tâches obsolètes

Si une tâche est en cours à partir d’une session précédente, l’agent reconnaît que la tâche peut être obsolète et offre des options pour continuer, redémarrer ou ignorer.

Travailler sur plusieurs sessions

De grandes mises à niveau, telles qu’une solution de 20 projets, une mise à niveau de framework complexe ou une modernisation à plusieurs étapes, s’étendent souvent sur plusieurs sessions sur plusieurs jours ou semaines. L’agent gère naturellement le travail multisession :

• État persistant : Tout est en .github/upgrades/. Aucun état en mémoire ne peut être perdu.
• Indépendance de session : Chaque session de conversation est indépendante. L’agent reconstruit son contexte à partir des fichiers d’état à chaque fois.
• Prise en charge multi-IDE : commencez dans VS Code, poursuivez dans Visual Studio ou Copilot CLI. Le dossier d’état sert de contrat partagé.

Conseils pour le travail multisession

• Validez le dossier d’état. Poussez .github/upgrades/ à votre branche afin de sauvegarder le dossier et de le rendre visible à votre équipe.
• Révisez entre les sessions. Lisez tasks.md et execution-log.md pour rafraîchir votre mémoire sur ce qui s’est déroulé au cours de la dernière session.
• Mettez à jour les préférences à mesure que vous apprenez. Si vous découvrez quelque chose dans les tests qui doit modifier l’approche de l’agent, indiquez à l’agent au début de la session suivante.

Demander de l’aide

Vous ne savez pas ce que l’agent peut faire ou où en sont les choses ? Demande :

Communiquer efficacement

La qualité de votre interaction affecte directement la qualité des résultats.

Être spécifique sur l’étendue

« Mettre à niveau uniquement les projets Data.Access et Data.Models vers .NET 10 donne à l’agent un focus clair. « Tout mettre à niveau » fonctionne, mais l’agent prend davantage de décisions par lui-même concernant l’ordre et les priorités.

Contexte de partage

L’agent ne connaît pas vos contraintes métier, sauf si vous les partagez :

• « Nous procédons à une mise à niveau, car Azure App Service supprime .NET 8 support en novembre.»
• « Il s’agit d’un service de production à trafic élevé : aucun changement comportemental dans les réponses de l’API . »

Définir les contraintes

Dites à l’agent ce qu’il ne doit pas faire, pas seulement ce qu’il doit :

• « Ne modifiez pas la surface d’API publique , nous avons des consommateurs externes. »
• « Nous ne pouvons pas encore mettre à niveau Newtonsoft.Json : l’équipe qui possède des contrats partagés n’a pas encore été mise à niveau. »
• « Ne touchez pas le module de création de rapports hérité , qui est réécrit séparément . »

Envoyer des commentaires

Les commentaires positifs aident autant que les corrections et confirme que l’agent est sur la bonne voie :

• « Cette mise à niveau semble excellente : effectuez la même approche pour l’autre projet de référentiel. »
• « Cela fonctionne, mais nous préférons l’injection de constructeur par rapport à l’injection de propriétés dans cette base de code. »

Référence rapide

Contenu connexe

• Quelle est la modernisation GitHub Copilot ?
• Concepts de base
• Bonnes pratiques
• Personnalisation de la modernisation GitHub Copilot
• Résoudre les problèmes de modernisation de GitHub Copilot