Débuter avec Claude Code ou Codex sans devenir dépendant de l’IA

Série « Apprendre à coder avec l’IA » — Article 1/7

TL;DR

Claude Code et Codex peuvent accélérer l’apprentissage d’un développeur junior. Mais ils peuvent aussi lui donner l’illusion de progresser simplement parce qu’une application fonctionne. La bonne méthode tient en cinq verbes : comprendre, tenter, demander, vérifier, expliquer.

Une application qui fonctionne ne prouve pas que tu sais coder

Aujourd’hui, un développeur débutant peut demander à un agent de créer une application complète en quelques minutes.

Une page de connexion. Un dashboard. Des appels API. Quelques tests. Une interface propre.

Tout fonctionne. Pourtant, il suffit souvent de poser trois questions pour découvrir le problème :

• Pourquoi ce composant est-il exécuté côté client ?
• Que se passe-t-il si l’API retourne une donnée invalide ?
• Comment modifier le comportement sans régénérer toute la fonctionnalité ?

Si le développeur ne peut pas répondre, il n’a pas encore appris à construire l’application. Il a appris à en demander une.

Le problème n’est pas Claude Code ou Codex. Le problème est la disparition de la boucle qui permet normalement d’apprendre : essayer, se tromper, chercher, comprendre, corriger.

L’IA supprime de la friction, y compris celle qui te faisait progresser

Une partie de la difficulté du développement est inutile. Passer une heure à retrouver une faute de frappe ne transforme personne en meilleur architecte.

L’IA peut retirer cette friction. Elle peut expliquer une erreur, retrouver un fichier, préparer un test ou comparer deux solutions.

Mais certaines difficultés sont formatrices :

• découper un problème trop large ;
• lire une documentation ;
• formuler une hypothèse ;
• comprendre une erreur de type ;
• choisir entre plusieurs implémentations ;
• mesurer les conséquences d’une dépendance.

Si l’agent prend aussi ces décisions, le junior obtient le résultat sans construire le raisonnement.

Notre fil rouge : un mini-dashboard

Dans cette série, nous allons suivre la construction d’un mini-dashboard avec TypeScript, React et Next.js.

Il affichera quelques métriques récupérées depuis une API : état d’un service, charge CPU simulée, mémoire utilisée et espace disque. Il devra gérer le chargement, les erreurs, les données invalides et plusieurs tests utiles.

Ce projet est volontairement simple. Il contient néanmoins tout ce qu’il faut pour apprendre :

• transformer un besoin en petites tâches ;
• distinguer données et affichage ;
• typer une réponse externe ;
• gérer les états d’une interface ;
• écrire et vérifier des tests ;
• déboguer une erreur ;
• refactoriser sans tout réécrire.

L’objectif ne sera jamais d’aller le plus vite possible. Il sera de savoir ce que nous avons appris à chaque étape.

La méthode en cinq verbes

1. Comprendre

Avant d’écrire un prompt, reformule le problème. Quelles sont les entrées ? Quel résultat attends-tu ? Quels cas peuvent échouer ?

Tu peux utiliser l’agent pour clarifier une notion, mais pas pour décider silencieusement de ce que tu voulais construire.

2. Tenter

Écris une première version. Elle peut être incomplète ou maladroite.

Cette tentative donne quelque chose de beaucoup plus utile à l’IA qu’une demande vague : ton raisonnement actuel. L’agent peut alors le relire, identifier une incompréhension et expliquer une amélioration précise.

3. Demander

Ne demande pas automatiquement la solution complète.

Demande un indice, une explication, une revue ou deux approches possibles. Plus la demande est ciblée, plus la réponse peut devenir pédagogique.

4. Vérifier

Lis le diff. Exécute le code. Contrôle les types. Lance les tests. Observe le comportement en cas d’erreur.

Un agent peut se tromper avec beaucoup d’assurance. La qualité d’une réponse ne se mesure pas à son apparence, mais à ce que tu peux vérifier.

5. Expliquer

Après la modification, ferme la réponse de l’IA et explique le code avec tes propres mots.

Si tu ne peux pas expliquer une ligne importante, tu n’as pas terminé la tâche. Tu viens seulement d’identifier ce qu’il reste à apprendre.

Un premier prompt qui protège l’apprentissage

Je débute avec TypeScript et React.

Ne modifie encore aucun fichier.
Commence par me poser les questions nécessaires pour vérifier ma compréhension du besoin.
Demande-moi ensuite de proposer moi-même un découpage.

Quand je te donnerai mon approche :
1. relève ce qui est correct ;
2. signale les risques sans donner immédiatement la solution ;
3. donne-moi un premier indice ;
4. attends ma nouvelle tentative.

Si je te demande finalement une modification, présente le plan et les fichiers concernés avant d’agir.

Ce prompt ne rend pas l’agent moins puissant. Il lui donne un rôle différent : il devient un interlocuteur pédagogique au lieu d’un générateur automatique.

Claude Code ou Codex : la méthode reste la même

Les deux outils peuvent explorer un dépôt, modifier des fichiers, exécuter des commandes et participer à la validation. Leurs interfaces, leurs mécanismes d’instructions et leurs autorisations diffèrent, mais le principe de contrôle reste identique.

Le junior doit savoir :

• ce que l’agent va faire ;
• quels fichiers ont changé ;
• comment le résultat a été vérifié ;
• comment revenir en arrière ;
• ce qu’il a personnellement compris.

Les documentations officielles présentent les principaux workflows de Codex et de Claude Code. Elles doivent rester les références pour les capacités et la configuration actuelles.

Le bon indicateur n’est pas le nombre de lignes produites

À la fin d’une session, ne demande pas seulement : « Est-ce que la fonctionnalité marche ? »

Demande-toi plutôt :

• Puis-on expliquer les choix importants ?
• Saurais-on retrouver l’origine d’un bug ?
• Puis-on modifier cette fonctionnalité sans tout régénérer ?
• Ai-on appris quelque chose de transférable vers un autre projet ?

L’IA peut accélérer la production. Ton rôle est de t’assurer qu’elle accélère aussi ta compréhension.

Dans le prochain article, nous préparerons le mini-dashboard avant de laisser un agent écrire la moindre ligne de code.