Prenez contact avec nous

Plan du cours

Du code autocomplété à l'agent : comprendre le changement

  • En quoi les suggestions de Copilot diffèrent-elles de la planification multi-étapes agentique ?
  • Architecture de la boucle agent : planifier, générer, exécuter, itérer.
  • Prise en charge des langages et sélection du modèle pour les tâches agent.
  • Exemples concrets : de fonctions de cinq lignes à des fonctionnalités multi-fichiers.

Activation du mode Agent dans votre IDE

  • Activation dans VS Code, JetBrains et Neovim.
  • Configuration de la fenêtre de contexte et des préférences de niveau de modèle.
  • Définir les règles de l'espace de travail et ignorer les fichiers binaires volumineux.
  • Gérer les workflows Chat Copilot par rapport aux workflows d'agent en ligne (inline).

Planification et exécution multi-étapes

  • Inciter Copilot à créer une fonctionnalité de bout en bout.
  • Observer l'agent décomposer les tâches en étapes sur plusieurs fichiers.
  • Vérifier chaque étape avant d'appliquer les modifications.
  • Utiliser le retour en arrière (rollback) en ligne lorsque les étapes dévient du chemin.

Commandes terminal au sein de la boucle agent

  • Installation des dépendances via l'intégration terminal de Copilot.
  • Exécution des commandes de build et interprétation de la sortie.
  • Gestion des variables d'environnement directement depuis les sessions Copilot.
  • Limites de sécurité : quelles commandes nécessitent une approbation manuelle ?

Développement piloté par les tests avec un agent

  • Génération de tests unitaires à partir du code source existant.
  • Piloter la création de tests via des prompts en langage naturel.
  • Exécution des suites de tests et interprétation des journaux d'échec dans Copilot.
  • Ajuster les assertions après avoir constaté des échecs sur des cas limites (edge-cases).

Navigation dans une base de code volumineuse

  • Trouver automatiquement les références inter-fichiers.
  • Refactoriser les utilitaires partagés avec des renommages guidés par Copilot.
  • Mettre à jour simultanément les fichiers de configuration et les fichiers de schéma.
  • Éviter l'épuisement de la fenêtre de contexte grâce à des prompts ciblés.

Personnalisation de Copilot pour respecter les normes d'équipe

  • Rédiger des instructions spécifiques au dépôt dans .github/copilot-instructions.md.
  • Faire respecter les conventions de nommage et les architectures cibles.
  • Exclure les fichiers sensibles et les répertoires du contexte.
  • Créer des modèles de prompts spécifiques à l'équipe pour les tâches courantes.

Gouvernance GitHub Copilot Entreprise

  • Attribution des licences (seats), facturation et tableaux de bord d'utilisation.
  • Journaux d'audit : suivre ce que Copilot a généré versus ce qui a été validé dans le code.
  • Policies Microsoft IP indemnity et implications en matière de licences.
  • Empêcher certains motifs de fichiers d'apparaître dans les pipelines de suggestion IA.

Débogage avec le mode Agent

  • Analyser les traces de pile ensemble avec l'agent.
  • Débogage hypothétique : demander à Copilot pourquoi un test a échoué.
  • Utiliser le bisect assisté par agent pour identifier les sources de régression.
  • Gérer les risques d'hallucinations lors du débogage de code inconnu.

Performance et gestion des limites

  • Comprendre les limites quotidiennes de requêtes et les quotas de modèles.
  • Optimiser la longueur des prompts pour éviter les réponses tronquées.
  • Changer de modèle en fonction des tâches.
  • Surveiller la latence de l'agent et mettre en œuvre des stratégies de mise en cache.

Sécurité et conformité pour les entreprises

  • Gestion des données : ce qui sort de votre dépôt et ce qui reste local.
  • Prévenir la fuite de secrets et d'identifiants via les prompts.
  • Conformité aux exigences GDPR, SOC 2 et FedRAMP.
  • Tests de pénétration (red-teaming) du code généré pour détecter les vulnérabilités d'injection.

Dépannage des scénarios courants

  • Pourquoi Copilot ignore parfois le contexte de votre base de code.
  • Résoudre les échecs d'indexation pour les dépôts volumineux.
  • Gérer les erreurs de limite de débit (rate limits) aux heures de pointe.
  • Corriger les problèmes de synchronisation des extensions IDE.

Résumé et feuille de route future

  • Bilan des capacités du mode Agent et des flux de travail pratiques.
  • Feuille de route Copilot de GitHub et prochaines fonctionnalités agent.
  • Ressources pour rester à jour avec les dernières versions de Copilot.

Pré requis

  • Expérience en programmation orientée objet ou fonctionnelle.
  • Compte GitHub et connaissances de base du flux de travail Git.
  • Familiarité avec au moins un IDE (VS Code, JetBrains ou Neovim).

Audience cible

  • Développeurs utilisant déjà Copilot et souhaitant débloquer le mode Agent.
  • Chefs de projet techniques déployant Copilot au sein des équipes de développement.
  • Équipes de sécurité évaluant les politiques de génération de code assistée par IA.
 21 Heures

Nombre de participants


Prix par participant

Cours à venir

Catégories Similaires