Résumé technique : Apprendre à coder avec du contexte : une approche basée sur l'étude

Problématique

L'émergence rapide des outils d'IA générative transforme le développement logiciel, nécessitant une adaptation de l'enseignement du génie logiciel. Bien que les étudiants utilisent fréquemment des outils d'IA à usage général (par exemple, ChatGPT, GitHub Copilot), ils rencontrent souvent des limitations significatives lorsqu'ils appliquent ces outils à des projets logiciels structurés et collaboratifs. Plus précisément, les modèles à usage général manquent de conscience du contexte spécifique au projet, notamment le code source propriétaire, la documentation du projet et les frameworks spécifiques au domaine (par exemple, jMonkeyEngine). Cela entraîne des « hallucinations », une génération de code inexacte et des échecs d'intégration, particulièrement lorsque les étudiants tentent d'utiliser l'IA pour la compréhension et l'implémentation de code plutôt que pour la simple génération de texte. De plus, il existe une inquiétude concernant la « dégradation des compétences », où une dépendance excessive à l'IA pourrait entraver le développement de capacités de résolution de problèmes indépendantes. Le défi central est de développer un système de support par l'IA qui fournit une assistance significative et sensible au contexte sans simplement fournir des solutions prêtes à l'emploi, tout en opérant dans des contraintes de protection des données qui imposent un déploiement local.

Méthodologie

Les auteurs ont employé une approche empirique en deux étapes au sein d'un cours de projet de programmation universitaire où des équipes d'étudiants développent des jeux informatiques multijoueurs en 3D utilisant Java et un modèle de processus en cascade (waterfall).

Étape 1 : Étude utilisateur (Quantitative et Qualitative)

• Contexte : Menée durant le trimestre d'octobre à décembre 2024 avec 38 participants (environ 78 % de la cohorte).
• Collecte de données : Un questionnaire structuré basé sur le Modèle d'Acceptation de la Technologie (TAM) a été administré lors des présentations finales des projets. Il a évalué l'utilisation de l'IA à travers quatre phases : Préparation, Analyse, Conception, et Codage & Tests.
• Focus : L'étude a examiné quelles tâches les étudiants effectuaient avec l'IA, l'utilité perçue, les gains de temps et les défis spécifiques rencontrés (ex. : manque de contexte, résultats inexacts).

Étape 2 : Étude de cas (Assistant LLM conscient du dépôt)

• Conception du système : Pour répondre aux limitations de contexte identifiées à l'étape 1, les auteurs ont développé un assistant de modèle de langage étendu (LLM) déployé localement et conscient du dépôt.
• Architecture :
  • Génération augmentée par récupération (RAG) : Le système emploie un mécanisme d'ancrage à double voie.
    1. RAG au niveau du document : Récupère la documentation du projet et les matériels auxiliaires via l'incorporation sémantique (semantic embedding).
    2. Recherche au niveau du code : Utilise des outils d'API GitLab en lecture seule (file_path_finder, get_content_from_file, get_methods) pour récupérer des fichiers de code source spécifiques et des signatures de méthodes basées sur les requêtes de l'utilisateur.
  • Déploiement : Le système fonctionne sur un serveur local NVIDIA DGX-H100 utilisant des conteneurs Docker. Il utilise vLLM pour le service de modèle (API compatible OpenAI) et Open WebUI pour l'interface de chat.
  • Confidentialité des données : Le déploiement local garantit le contrôle des données et la reproductibilité, répondant aux exigences institutionnelles de protection des données.
• Évaluation :
  • Tâches : Deux tâches représentatives de la phase « Préparation » du projet Battleship ont été utilisées : (1) Ajouter des modèles 3D pour les navires en fonction de leur longueur, et (2) Implémenter les commandes de musique de fond.
  • Variables : L'étude a réalisé un « balayage d'échantillonnage » (variation de temp, top_p, min_p) et un « balayage de modèles » (testant six modèles allant de 7B à 236B de paramètres, incluant des variantes de DeepSeek-Coder, Mistral et Qwen).
  • Analyse : Les sorties générées ont été analysées par rapport à un « Catalogue de défauts » contenant 12 catégories d'erreurs (ex. : Hallucination, Mauvaise utilisation d'outil, Robustesse insuffisante, Entrée de ressource manquante).

Contributions clés

1. Preuve empirique des limitations de contexte : L'étude utilisateur fournit des données quantitatives démontrant que, bien que les étudiants adoptent massivement l'IA pour la documentation et les exigences (tâches riches en texte), ils éprouvent des difficultés significatives avec la compréhension et l'implémentation du code en raison du manque de contexte du projet dans les outils à usage général.
2. Architecture d'assistant conscient du dépôt : L'article présente une implémentation concrète d'un assistant basé sur le RAG, déployé localement, qui intègre la récupération de documents avec des recherches de code au niveau du dépôt. Ce système est conçu pour ancrer les réponses dans les artefacts réels du projet.
3. Catalogue de défauts pour l'IA dans l'éducation : Les auteurs définissent un catalogue spécifique de 12 types de défauts récurrents observés lorsque les LLM interagissent avec des dépôts logiciels, fournissant un cadre pour l'analyse qualitative du comportement de l'IA en milieu éducatif.
4. Analyse de sensibilité des paramètres et des modèles : L'étude offre des conclusions empiriques sur la façon dont les paramètres d'échantillonnage (spécifiquement la température et min_p) et la taille du modèle affectent la fréquence de défauts spécifiques (ex. : hallucinations) dans un contexte conscient du dépôt.

Résultats

Résultats de l'étude utilisateur

• Adoption : 89,4 % des participants ont utilisé des outils d'IA. L'adoption était la plus élevée dans la phase Codage & Tests (33/38 utilisateurs) et la plus faible dans la phase de Conception (10/38 utilisateurs).
• Utilité : L'IA a été jugée « utile » ou « très utile » pour les phases de Préparation et de Codage & Tests, particulièrement pour la documentation et la génération de code. Cependant, elle a été jugée la moins utile (souvent « neutre » ou « non utile ») lors de la phase de Conception, principalement en raison de l'incapacité de l'IA à générer des diagrammes précis (classes, séquences, états).
• Défis : Les principaux problèmes signalés étaient les « résultats inexacts », le « manque de contexte » (l'IA ne connaissant pas le code spécifique du projet ou les frameworks comme jMonkeyEngine) et les « hallucinations » (génération de méthodes inexistantes).
• Perception : Malgré les défis, 24 des 34 utilisateurs ont estimé que l'IA leur faisait gagner un temps considérable, et la majorité a exprimé l'intention d'utiliser l'IA dans de futurs projets.

Résultats de l'étude de cas

• Efficacité du contexte : L'assistant conscient du dépôt a produit de manière constante des sorties plus alignées avec la structure du projet par rapport aux outils généraux observés dans l'étude utilisateur. L'ancrage des réponses dans les artefacts réels du dépôt a réduit les problèmes d'intégration.
• Modèles de défauts :
  • Hallucination : Est restée le défaut le plus fréquent (survenant dans 14/15 configurations d'échantillonnage), particulièrement à des températures élevées ($T=1.0$). Cependant, la capacité du système à récupérer des fichiers a souvent permis une autocorrection lors des tours suivants.
  • Entrée de ressource manquante : Un défaut récurrent dans presque tous les modèles et configurations, où le modèle échoue à enregistrer de nouvelles ressources (ex. : clés de localisation) malgré la récupération réussie de la documentation pertinente. Cela suggère un « fossé entre la récupération et l'action ».
  • Paramètres d'échantillonnage : La configuration $T \approx 0.5$, $top\_p = 0$ (ou faible) s'est avérée la plus stable, produisant le moins de défauts. Les températures élevées combinées à des filtres augmentaient souvent les taux d'erreur.
• Performance des modèles :
  • La taille du modèle n'a pas eu de corrélation linéaire avec le succès. Le modèle Devstral-Small-2505 de 24B a produit des sorties très utilisables, tandis que le Mistral-7B de 7B a échoué à terminer les tâches sans un suivi extensif.
  • Les modèles très larges (ex. : 235B) fournissaient un raisonnement détaillé mais ne surpassaient pas systématiquement les modèles de taille moyenne en termes de fidélité d'intégration.
  • Un problème récurrent chez tous les modèles a été l'incapacité à utiliser efficacement le contexte récupéré pour des actions spécifiques (ex. : écrire dans des fichiers de ressources), indiquant que l'intégration des outils est un goulot d'étranglement indépendant de la taille du modèle.

Signification et affirmations

L'article affirme que l'intégration de la récupération sensible au contexte (spécifiquement l'ancrage dans le dépôt) est une étape critique pour rendre l'IA utile dans l'enseignement du génie logiciel. Les auteurs soutiennent que si les outils d'IA à usage général sont précieux pour les tâches textuelles, ils sont insuffisants pour l'implémentation de code sans accès aux artefacts spécifiques au projet.

L'étude démontre qu'un assistant local, conscient du dépôt, peut atténuer la « faiblesse d'intégration » de l'IA générale, produisant des sorties plus cohérentes et reproductibles. Cependant, les auteurs restent modestes quant à l'état actuel de la technologie, reconnaissant que :

• Les hallucinations et le mauvais usage des outils persistent même avec le RAG.
• La génération de diagrammes et la conception visuelle restent des domaines où le support de l'IA est faible.
• La dégradation des compétences est un risque ; par conséquent, la direction future proposée n'est pas une IA qui résout les problèmes pour les étudiants, mais un « tuteur » qui fournit des indices et guide la résolution de problèmes indépendante.

La signification de ce travail réside dans son passage de l'évaluation d'outils d'IA génériques à l'ingénierie et l'évaluation d'assistants IA spécifiques au contexte qui respectent la confidentialité des données et les objectifs éducatifs, offrant un modèle de la manière dont de tels systèmes peuvent être intégrés dans les cursus de génie logiciel.