Qu'est-ce que l'Agentic Coding ?

Jusqu'ici, tu as surtout utilisé l'IA dans un chat : tu poses une question, l'IA répond. Si tu lui fais écrire du code de cette manière, tu copies le code du chat dans un fichier, tu l'essaies et tu renvoies le message d'erreur. Tu es le messager entre l'IA et l'ordinateur.

Avec l'Agentic Coding, ce rôle de messager disparaît. Un agent de codage travaille directement dans ton dossier de projet : il lit des fichiers, écrit du code, exécute des commandes, lance des tests et corrige ses propres erreurs. Tu décris ce que tu veux et tu vérifies ce qui en sort.

Cela ressemble à «l'IA programme, je me détends». Ce n'est pas si simple. Dans cette masterclass, tu apprends à guider un agent de codage pour obtenir un logiciel utile et sûr. Le principe directeur de tout le cours est :

«L'agent écrit le code. Tu restes responsable»

Trois niveaux d'assistance par l'IA

L'IA peut t'aider à programmer de trois manières. Les frontières sont floues, mais la façon de travailler change beaucoup :

Fonctionnement : Tu décris dans un chat ce dont tu as besoin. L'IA fournit du code sous forme de texte. Tu le copies dans un fichier et tu le testes toi-même.

Ce que l'IA voit : uniquement ce que tu colles dans le chat.

Utile pour : des scripts courts, des explications, des formules isolées.

Fonctionnement : L'IA est intégrée dans un éditeur de code. Elle propose les lignes suivantes pendant que tu tapes, ou modifie sur demande un passage sélectionné.

Ce que l'IA voit : le fichier ouvert et souvent quelques fichiers voisins.

Utile pour : les personnes qui programment elles-mêmes et veulent aller plus vite.

Fonctionnement : Tu donnes une consigne. L'agent cherche lui-même les fichiers nécessaires, planifie, modifie plusieurs fichiers, exécute des commandes et vérifie le résultat. Il continue par étapes jusqu'à ce qu'il considère la consigne comme accomplie ou qu'il te pose une question.

Ce que l'IA voit : tout ce qu'elle ouvre dans le dossier de projet, ainsi que les sorties des commandes qu'elle exécute.

Utile pour : des fonctionnalités complètes, la recherche d'erreurs sur plusieurs fichiers, de petites applications de A à Z.

Pour cette masterclass, seul le troisième niveau compte. Parmi les agents de codage connus figurent Claude Code, OpenAI Codex, Gemini CLI, Grok Build, Cursor ou l'agent de GitHub Copilot. Ils diffèrent par leur utilisation et leur prix, mais fonctionnent selon les mêmes principes. Ce sont ces principes que tu apprends ici. L'utilisation d'un outil précis est présentée dans le cours sur cet outil.

Comment travaille un agent de codage

Un agent de codage est un modèle de langage qui a le droit d'utiliser des outils. Les outils typiques sont :

Lire des fichiers et chercher dans le projet
Créer et modifier des fichiers
Exécuter des commandes, par exemple lancer des tests ou installer un programme
selon l'outil : chercher sur le web, ouvrir une page dans le navigateur, accéder à des services externes

Avec ces outils, l'agent travaille en boucle, la boucle de l'agent :

Planifier : Quel est l'objectif, quelle est la prochaine étape sensée ?
Agir : utiliser un outil, par exemple ouvrir un fichier ou lancer un test.
Observer : lire le résultat, comme le contenu du fichier ou un message d'erreur.
Évaluer : Ai-je progressé ? L'objectif est-il atteint ? Dois-je corriger quelque chose ?

Ensuite, la boucle recommence. Une seule consigne peut déclencher des dizaines d'étapes sans que tu interviennes.

Une consigne, beaucoup d'étapes

Tu écris : «Le temps total de la randonnée est mal calculé. Trouve l'erreur et corrige-la.»

L'agent cherche le calcul dans le projet (agir), lit le fichier trouvé (observer), soupçonne une erreur dans les descentes (évaluer), lance les tests (agir), voit échouer un test qui confirme son soupçon (observer), modifie une ligne (agir), relance les tests, et tous sont verts. Puis il annonce : «Erreur corrigée.»

Tu as écrit un message. L'agent a fait huit étapes. Mais tu ne sais pas encore si la correction est vraiment juste. Tu apprends à le vérifier dans les leçons «Vérifier plutôt que croire» et «Git comme filet de sécurité».

Ton nouveau rôle

Avec l'Agentic Coding, tu n'écris presque plus de code. Ton travail se déplace vers quatre tâches qu'aucun agent ne fait à ta place :

Donneur d'ordre : Tu décides ce qui est construit et tu le décris de manière vérifiable.
Architecte : Tu fixes les règles : quelle technique, quel style, ce qui est interdit.
Surveillance : Tu détermines ce que l'agent peut faire sans demander et où il doit s'arrêter.
Réception : Tu vérifies le résultat et tu le valides, ou non.

Une image utile : l'agent est un collaborateur extrêmement rapide et travailleur, qui ne se fatigue jamais, mais qui raconte parfois des bêtises avec beaucoup d'assurance. À un tel collaborateur, tu donnes des consignes claires, des limites strictes, et tu contrôles son travail avant qu'il n'arrive chez le client.

Tu n'as pas besoin de savoir programmer. Cette masterclass ne suppose aucune connaissance en programmation. Mais tu apprendras assez pour lire du code dans les grandes lignes, comprendre les modifications et repérer les signaux d'alerte. C'est la différence entre «l'IA a construit quelque chose» et «je sais ce que je livre».

Ce qui fonctionne bien et ce qui ne fonctionne pas

Là où ils ont particulièrement besoin de toi

objectifs flous : l'agent comble les lacunes avec ses propres hypothèses
grandes décisions d'architecture aux conséquences durables
sécurité, paiements, données personnelles
tout ce qui se passe directement dans un système en production
longues sessions où l'agent perd la vue d'ensemble

Là où les agents sont forts

tâches bien délimitées avec un résultat vérifiable
prototypes et petits outils internes
travail de routine : formulaires, tableaux, renommages, ajout de tests
expliquer du code inconnu et cerner des erreurs
rédiger de la documentation

Se sentir plus rapide n'est pas être plus rapide En juillet 2025, l'organisation de recherche METR a publié une étude contrôlée : 16 développeurs open source expérimentés ont réalisé 246 tâches réelles dans des projets qu'ils connaissaient depuis des années, en partie avec et en partie sans outils d'IA. Avec l'IA, ils ont mis en moyenne environ 19 % plus de temps. Avant, ils s'attendaient à être 24 % plus rapides, et même après, ils pensaient avoir été environ 20 % plus rapides. L'étude est petite et concerne des outils du printemps 2025 et des professionnels dans du code familier. La leçon reste valable : ne te fie pas à ton impression, vérifie les résultats et l'effort.

«Vibe coding» : quand cela suffit et quand ce n'est pas le cas

En février 2025, le chercheur en IA Andrej Karpathy (cofondateur d'OpenAI, ancien responsable de l'IA chez Tesla) a forgé l'expression vibe coding. Il décrivait ainsi sa façon de construire des logiciels en disant simplement à l'IA ce qu'il voulait, en acceptant les modifications sans les lire et en recollant tout simplement les messages d'erreur. Il ne regardait presque plus le code lui-même. Il ajoutait que pour des projets jetables du week-end, ce n'était pas si mal.

L'expression s'est répandue, souvent sans cette restriction. Pour toi, la distinction est importante :

Le vibe coding est dangereux

Un site web avec formulaire de contact, un outil avec des données clients, tout ce qui touche aux paiements ou à la connexion, tout ce que d'autres personnes utilisent. Ici, tu dois savoir ce que tu livres.

Le vibe coding convient

Un prototype jetable pour tester une idée. Un jeu pour toi. Une démo sans vraies données. Si ça casse, rien n'est perdu.

L'Agentic Coding tel que tu l'apprends ici est le contraire d'une acceptation aveugle : tu profites de la vitesse de l'agent, mais tu gardes le contrôle sur l'objectif, les règles et le résultat.

La responsabilité reste la tienne. Si un site perd des données ou si un formulaire envoie du spam, personne ne demande quel agent a écrit le code. Le responsable est celui qui exploite le logiciel. Un agent ne répond de rien, ne signe aucun contrat et ne se présente devant aucun tribunal.

Ce qui t'attend dans cette masterclass

Les 12 leçons suivent le déroulement d'un vrai projet :

Préparer : environnement de travail, bonnes consignes, contexte et règles du projet (leçons 2–4)
Réaliser : planifier, développer pas à pas, travailler avec du code existant (leçons 5–7)
Sécuriser : vérifier, Git comme filet de sécurité, sécurité et autorisations (leçons 8–10)
Aller plus loin : workflows réutilisables, du prototype à la mise en production (leçons 11–12)

À partir de la leçon 2, tu travailles avec un petit projet d'exercice, le Hike Planner, un outil pour planifier des randonnées. Pour cela, tu as besoin d'un agent de codage de ton choix. La plupart des fournisseurs exigent un abonnement payant. Le cours sur ton outil te montre comment le configurer.

Exercice : tes candidats

Avant de commencer avec l'outil, pense à ton propre travail. Note trois choses que tu aimerais construire ou améliorer avec un agent de codage, par exemple un formulaire, une analyse de données Excel ou un petit outil interne.

Classe chacune d'elles :

Est-ce un prototype (juste pour toi, jetable) ou quelque chose en production (d'autres l'utilisent, vraies données) ?
Quelles données traite-t-il ? Y a-t-il des données personnelles ou des secrets d'affaires ?
À quoi verrais-tu que cela fonctionne correctement ?

Garde la liste. Elle deviendra ton projet final dans la leçon 12.

Après une consigne, l'agent annonce : «Erreur corrigée, tous les tests sont verts.» Qu'est-ce qui est correct ?

Exact. Les agents peuvent mal adapter des tests, passer à côté d'erreurs ou simplement se tromper. La réception reste ta tâche.

Pas tout à fait. Un message de fin est une affirmation de l'agent. Tu montres qu'elle est vraie par ta propre vérification : regarder la modification, contrôler les tests, essayer toi-même.

Points clés :

Un agent de codage lit, écrit et teste du code de manière autonome dans ton dossier de projet, dans une boucle : planifier, agir, observer, évaluer.
Ton rôle : donneur d'ordre, architecte, surveillance et réception. L'agent écrit le code, tu restes responsable.
Les agents sont forts pour des tâches claires et vérifiables, faibles pour des objectifs flous, la sécurité et les systèmes en production.
La vitesse ressentie est trompeuse. Vérifie des résultats, pas des impressions.
Le vibe coding suffit pour des prototypes jetables, pas pour des logiciels que d'autres utilisent.

Cette leçon fait partie d'un cours avec examen final et certificat. Voir le cours «Agentic Coding»