Si quelqu’un te dit que utiliser des modèles de langage (LLMs) pour programmer est un jeu d’enfant, soit il te trompe, soit il a eu la chance de trouver une formule qui échappe à la plupart d’entre nous. Parce qu’en toute honnêteté, faire en sorte qu’un LLM te rédige du bon code n’est pas intuitif. C’est comme avoir un assistant qui peut être incroyablement efficace… ou totalement imprévisible.
Voici le dilemme : certains obtiennent des résultats spectaculaires tandis que d’autres finissent frustrés avec des réponses incohérentes ou du code qui ne fonctionne tout simplement pas. Quelle est la différence ? Les attentes et la stratégie.
Ainsi, je me suis basé sur l’article de Simon Willison, un programmeur britannique de renom, pour rassembler ici les meilleures stratégies pour que l’IA soit ton compagnon de voyage à partir de maintenant (de celles dont tu ne souhaites pas qu’elle descende de la voiture).
Tout d’abord, il faut admettre que les LLMs ne sont pas des outils magiques. Ce sont des modèles qui prédissent le mot suivant en se basant sur des motifs, et bien que cela les rende extrêmement utiles, cela les rend aussi imprévisibles. Ils excellent à écrire du code, mais cela ne signifie pas qu’ils le font toujours bien. Parfois, ils peuvent inventer des fonctions qui n’existent pas ou commettre des erreurs qu’un humain ne ferait jamais.
Le truc est de comprendre qu’un LLM ne remplace pas le programmeur, mais amplifie sa capacité.
Il ne s’agit pas de lâcher une idée vague et d’attendre un code prêt pour la production, mais de les utiliser comme un assistant rapide, capable de générer des exemples, d’automatiser des tâches répétitives et de t’aider à explorer de nouvelles façons de résoudre un problème.
Mais bien sûr, ils ont aussi leurs limites. Leur connaissance est ancrée à la date à laquelle ils ont été entraînés, donc si un framework a changé radicalement après ce moment, le modèle n’en aura aucune idée. Pour faire face à cela, il faut lui donner des informations à jour ou vérifier en profondeur ce qu’il génère.
Donc, première leçon : 💡 si tu attends qu’un LLM fasse le travail sans supervision, tu vas être déçu. Mais si tu l’utilises comme un renfort stratégique, tu peux gagner en vitesse et en créativité dans ton code comme jamais auparavant.
Le truc est dans le contexte : comment tirer parti des LLMs
S’il y a un secret pour tirer profit d’un modèle de langage lorsque tu programmes, c’est celui-ci : le contexte est tout. Peu importe si tu utilises ChatGPT, Claude ou Gemini, la différence entre recevoir un code utile ou un désastre total dépend en grande partie de comment tu gères l’information que tu lui donnes.
D’abord, il faut comprendre comment fonctionnent ces modèles. Ils n’ont pas de mémoire à long terme ; ce qu’ils savent à un moment donné, c’est ce qui est dans le contexte de la conversation. ☝🏼 Chaque fois que tu commences un nouveau chat, c’est comme si tu parlais à quelqu’un qui vient de naître et qui n’a aucune idée de ce que tu lui as dit auparavant. Cela signifie que si la conversation commence à dérailler, parfois le mieux est de recommencer à zéro.
Cela dit, certains environnements de développement qui intègrent des LLMs ont trouvé des moyens d’améliorer cela. Des outils comme Cursor ou VS Code Copilot peuvent automatiquement alimenter le contexte avec le contenu des fichiers ouverts ou même avec de la documentation pertinente. Cela permet au modèle de travailler avec plus d’informations et de donner des réponses beaucoup plus précises.
Mais même sans outils avancés, il existe des moyens d’améliorer le contexte manuellement. ☝🏼 Une des meilleures stratégies est de lui donner des exemples concrets. Au lieu de lui demander quelque chose de manière générique, donne-lui du code précédent qui suit la structure dont tu as besoin et demande-lui de l’adapter. Une autre option est d’alimenter le modèle avec plusieurs solutions similaires et de lui demander de créer une nouvelle solution basée sur ces motifs.
Il est également essentiel de savoir quand alimenter le modèle avec de la documentation externe. Si tu utilises une bibliothèque que le modèle ne connaît pas (parce qu’elle est sortie après sa dernière mise à jour), tu peux copier et coller des exemples récents et lui faire prendre cela en compte.
Et quelque chose que beaucoup de gens ne profitent pas : ☝🏼 les LLMs peuvent beaucoup s’améliorer si tu les fais travailler par itérations. Ne t’attends pas à ce qu’ils donnent la réponse parfaite du premier coup. Essaie de demander une version simple, vérifie si ça fonctionne bien, puis demande-lui de l’optimiser ou de la rendre plus avancée. Ainsi, tu as le contrôle sur le résultat et tu peux le façonner selon tes besoins.
💡 Deuxième leçon importante : si tu apprends à gérer le contexte, tu peux faire passer un LLM d’un perroquet répétitif à un véritable assistant de programmation.
De stagiaire numérique à compagnon de code : instructions claires, meilleurs résultats
Voici une autre clé fondamentale : ☝🏼 les LLMs fonctionnent mieux quand tu leur dis exactement quoi faire. Si tu les traites comme un coéquipier expérimenté qui « sait déjà » comment tout fonctionne, ils vont te décevoir. Mais si tu les vois comme un stagiaire numérique qui a besoin d’instructions précises, la donne change.
Lorsque tu demandes du code à un LLM, la différence entre un résultat médiocre et un résultat utile réside dans comment tu expliques la tâche. Ce n’est pas la même chose de dire :
🔴 “Fais-moi une fonction en Python pour télécharger un fichier”
que
🟢 “Écris une fonction en Python appelée download_file(url: str) -> pathlib.Path qui utilise httpx pour télécharger un fichier et le sauvegarder dans un dossier temporaire. Si le fichier dépasse 5 Mo, il doit lancer une erreur. Retourne le chemin du fichier sauvegardé.”
Le premier prompt est trop vague et le modèle pourrait inventer n’importe quoi. Le second précise déjà ce qu’il doit faire, comment la fonction doit s’appeler, quels paramètres elle doit recevoir, quelle technologie utiliser, quelles contraintes suivre et ce qu’elle doit retourner.
Une autre stratégie infaillible : ☝🏼 faire écrire du code au modèle par blocs. D’abord, demande-lui la fonction principale. Ensuite, demande-lui d’écrire les tests unitaires avec pytest. Après, demande-lui d’ajouter la gestion des erreurs. Ainsi, tu gardes le contrôle et peux corriger à chaque étape.
Et quelque chose qui surprend beaucoup de gens : ☝🏼 dicter du code en anglais peut être plus efficace. Bien que les LLMs comprennent plusieurs langues, leur entraînement est souvent basé sur de la documentation et du code en anglais, donc ils obtiennent souvent de meilleurs résultats si tu leur donnes les instructions dans cette langue.
Quel est le résultat final ? Si tu sais donner des instructions claires, le LLM non seulement te fait gagner du temps, mais te renvoie également un code plus propre et avec moins d’erreurs.
Vitesse, apprentissage et erreurs : le combo gagnant des LLMs
S’il y a quelque chose dans lequel les LLMs brillent vraiment, c’est dans la vitesse. Ce n’est pas qu’ils font tout parfaitement, mais quand tu apprends à bien les utiliser, ils te permettent de développer plus rapidement et d’essayer des idées que tu ne te donnerais même pas la peine d’essayer autrement.
Pense à ces projets que tu as en tête, mais que tu ne commences jamais parce que tu n’as pas envie de rechercher chaque détail depuis le début. C’est là qu’un LLM peut changer la donne. Au lieu de perdre des heures à chercher comment structurer quelque chose, tu peux lui demander un prototype en quelques minutes et partir de là… Et oui, le code initial peut ne pas être parfait, mais au moins tu as un point de départ.
De plus, ☝🏼 utiliser des LLMs est une manière incroyable d’apprendre. Si tu leur donnes un bon contexte et que tu sais les guider, ils peuvent t’expliquer du code, te suggérer des améliorations et même te montrer des alternatives que tu n’avais pas envisagées. C’est comme avoir un tuteur qui ne se fatigue jamais de répondre aux questions, peu importe combien de fois tu lui demandes la même chose.
Cela dit, il faut garder une chose à l’esprit : ☝🏼 les erreurs font partie du processus. Tu ne peux pas faire aveuglément confiance à ce qu’un modèle d’IA te renvoie. Tu dois toujours, toujours tester le code. Peu importe à quel point la réponse semble convaincante, si tu ne l’exécutes pas et ne valides pas, tu ne peux pas supposer qu’elle fonctionne.
Mais voici ce qui est intéressant : les erreurs aident aussi à comprendre les limites de l’outil. Si tu découvres qu’un modèle échoue toujours dans une certaine tâche, tu peux anticiper, lui donner plus de contexte ou même changer ton approche.
En définitive, les LLMs ne sont pas une baguette magique, mais si tu les utilises bien, ils peuvent te faire programmer plus vite, apprendre plus et amener tes projets à un autre niveau. Cela dit, le contrôle final doit toujours être entre les mains de l’humain.
