Atelier : votre application, puis votre skill
Atelier · semaine 3 · seul sur votre poste, puis en groupe dans le dépôt du projet 2
Slides du cours
À télécharger
Vous appliquez ici la méthode du chapitre « Programmer avec un agent ». Seul, vous construisez une application de votre choix en quatre tours. En groupe, vous posez le kit de départ dans le dépôt du projet 2, puis vous écrivez le skill de votre stack.
À la fin de cet atelier, vous serez capables de :
- mener un petit projet avec un agent, de l'analyse au commit, en vérifiant l'écran vous-mêmes ;
- installer le kit dans le dépôt du projet 2 et tenir votre état dans
docs/<prénom>/; - écrire le skill de la stack de votre groupe, puis vérifier qu'un agent le charge et le suit.
| Durée | Contenu |
|---|---|
| ≈ 35 min | Théorie et démonstrations (les deux chapitres précédents, à relire ensuite) |
| ≈ 45 min | Votre application, seul (partie 1) |
| ≈ 5 min | Le kit dans le dépôt du projet 2 (partie 2) |
| ≈ 45 min | Le skill du groupe (partie 3) |
| le reste | Votre projet : vous testez, validez et améliorez vos skills (partie 4) |
1. Votre application, seul, en 45 minutes
Trouvez une idée d'outil qui vous servirait vraiment : dans votre vie d'étudiant, à votre travail ou dans votre vie de tous les jours. Un petit jeu convient aussi. Rien n'est imposé : plusieurs écrans, une base de données, une clé d'API si vous en avez une, la stack de votre choix. L'application ne va pas dans le dépôt du projet 2.
Quelques pistes, si rien ne vient :
| Pour | Idées |
|---|---|
| Votre vie d'étudiant | un minuteur de révision qui récompense la concentration · des cartes de révision tirées de vos notes · un planning d'examens avec compte à rebours |
| Votre travail | un suivi des heures par client · un générateur de comptes rendus de réunion · un convertisseur pour un format que vous manipulez chaque jour |
| Votre vie de tous les jours | le partage des dépenses d'une colocation · un menu de la semaine avec sa liste de courses · un suivi d'entraînement |
| Jouer | un quiz entre amis · un jeu de mémoire · un petit jeu d'arcade |
Créez un dossier vide. Ouvrez un terminal dedans, tapez git init, puis ouvrez ce dossier dans votre agent.
L'exemple de ce chapitre s'appelle « Pousse » : un minuteur de révision où une plante grandit pendant que vous travaillez. Il a été construit pour de vrai en suivant les tours de cette partie, avec OpenCode et un modèle gratuit, Big Pickle. Les durées et les réponses citées sont celles de cet essai.
La fiche, 5 minutes
Avant de parler à l'agent, décrivez votre idée en quelques phrases, comme vous la raconteriez à un ami. Ajoutez cinq lignes : pour qui, ce qu'elle fait, ce qu'elle ne fait pas, la stack, et ce que « fini » veut dire. La ligne « ce qu'elle ne fait pas » compte le plus : c'est là que vous coupez.
Tour 1 : l'analyse, pas le code (5 minutes)
Votre fiche entre dans la demande. Voici celle de « Pousse » :
Je veux construire une petite application web avec toi.
L'idée : un minuteur de révision qui me donne envie de rester concentré. Je
lance une session de 25 minutes, et pendant que je travaille une petite plante
pousse à l'écran, étape par étape. Si je quitte l'onglet trop longtemps, elle
se fane. À la fin de la session, la plante rejoint mon jardin, et je vois
combien de plantes j'ai fait pousser cette semaine.
- Pour qui : moi, étudiant en cours du soir, qui révise sur mon portable ou
sur mon téléphone.
- Ce qu'elle fait : une session de travail chronométrée (25 minutes par
défaut, réglable), une plante dessinée qui grandit en cinq étapes, un jardin
avec les plantes des sessions finies, le total de la semaine.
- Ce qu'elle ne fait pas : pas de compte, pas de serveur, rien n'est envoyé
sur le réseau. Pas de son, pas de notification.
- Stack : Vite et TypeScript sans framework, Vitest pour les tests. Plantes
dessinées en SVG. Interface en français, code en anglais.
- Fini veut dire : l'application tourne en local, la logique (étapes de la
plante, plante fanée, total de la semaine) est testée, la page se lit sur un
téléphone, et il y a un commit.
N'écris aucun code et ne crée aucun fichier maintenant. Donne-moi d'abord ce
que tu as compris, ton plan en étapes avec le temps que tu estimes pour
chacune, la liste des fichiers, et tes questions. Est-ce que j'ai oublié
quelque chose ?
Vérifiez que l'agent n'a créé aucun fichier. Ici, il a répondu en 78 secondes : ce qu'il a compris, un plan en neuf étapes, dix-huit fichiers, six questions et neuf oublis possibles. Le début de ses deux premières questions :
1. "Quitte l'onglet trop longtemps" — quel seuil, et quelle sanction ? Je
propose : on cumule le temps où `document.hidden` est vrai ; au-delà de
60 s cumulées, la plante fane. Une session fanée ne rejoint pas le jardin.
[…]
2. Peut-on mettre en pause ? […]
Il a aussi relevé ce que la fiche ne disait pas : que devient la session si on recharge la page au milieu ? Sans ces questions, l'agent aurait choisi seul.
Son plan annonçait « ≈ 6 h de travail effectif ». Ne coupez pas votre idée pour autant. Un agent estime en heures d'humain, et il va dix à vingt fois plus vite : le tour suivant a pris 24 minutes.
Tour 2 : répondre, couper, construire (25 minutes avec le tour 3)
À la fin de chaque tour, l'agent vous dit ce qu'il a fait. S'il y a lieu, il dit aussi ce qu'il compte faire et les questions à trancher. Copiez-collez son message et répondez ligne par ligne, en commençant chaque réponse par > :
1. "Quitte l'onglet trop longtemps" : quel seuil, et quelle sanction ?
> 60 s cumulées, ok. Plus doux : la plante fanée rejoint quand même le jardin,
mais elle ne compte pas dans le total de la semaine.
2. Peut-on mettre en pause ?
> non, plus simple. On peut seulement abandonner.
6. Simple page web, ou installable (PWA) ?
> simple page web. Pas de PWA, hors périmètre.
Ton plan me va, mais 6 heures c'est une estimation d'humain : tu vas beaucoup
plus vite. Construis tout maintenant, en une fois. Pour que je puisse tester
sans attendre 25 minutes, ajoute un paramètre d'adresse ?demo=1 où une session
dure 60 secondes.
Quand c'est fait, lance les tests et le build et montre-moi leurs sorties
réelles. Termine par deux listes : ce que tu as vérifié, ce que tu n'as pas
vérifié. Ne fais pas de commit, je veux d'abord voir l'écran.
Trois choses sont à retenir de cette réponse. Elle coupe : pas de pause, pas d'application installable. Elle demande un moyen de tester vite, le mode ?demo=1. Elle exige des preuves et interdit le commit.
L'agent a travaillé 24 minutes, puis il a montré ses sorties :
Test Files 8 passed (8)
Tests 60 passed (60)
En se vérifiant, il a trouvé seul deux bugs, dont celui-ci : le mode démo écrivait dans la vraie sauvegarde. Sa liste « Pas vérifié » contenait ces lignes :
- L'apparence : je ne peux pas lire les images dans cette session (le modèle
n'accepte pas les entrées image). La composition des SVG, les espacements et
le rendu « joli » sont à juger par toi.
- La fanaison de bout en bout dans un navigateur : validée en unitaire
seulement.
- Une session réelle de 25 minutes : raccourcis d'horloge et tests unitaires,
pas d'attente réelle.
Ce qu'il ne voit pas, vous le regardez. Lancez l'application dans un terminal avec la commande qu'il vous donne (npm run dev ici), ou demandez-lui de relancer le serveur. Ouvrez l'adresse affichée. Dans le navigateur, F12 puis Ctrl+Maj+M affichent la page à la largeur d'un téléphone. Faites un vrai parcours : ici, une session en mode démo, du premier clic à la plante dans le jardin.

Les 60 tests et le build étaient verts. Pourtant la plante, le cœur de l'application, était petite et perdue sous un grand vide.
Tour 3 : critiquer l'écran
Écrivez ce que vous voyez, puis ce que vous voulez :
J'ai regardé l'écran. (Nombre) choses me gênent :
1. Sur (téléphone / grand écran), (ce que vous voyez). (Ce que vous voulez à la place.)
2. (…)
Corrige ces points, rien d'autre. Relance les tests et le build, et dis-moi
ce que tu as vérifié et ce que tu n'as pas vérifié. Toujours pas de commit.
Vous pouvez aussi joindre une capture d'écran annotée : entourez, soulignez ou surlignez ce qui est à corriger. Vérifiez d'abord que votre modèle lit les images. Big Pickle ne les lit pas, et il l'a dit.
Pour « Pousse », trois défauts : une plante trop petite sous un grand vide, un bandeau démo rose qui ressemble à une erreur, et un jardin invisible sur téléphone à la fin de la session. L'agent a corrigé en 3 min 23, puis il s'est arrêté sans rien conclure. Une relance a suffi :
Tu t'es arrêté sans conclure. Dis-moi seulement ce que tu as changé pour
chacun des trois points, ce que tu as vérifié et ce que tu n'as pas vérifié.
Il a répondu en 28 secondes. Sa liste « Pas vérifié » commençait ainsi : « Le rendu réel des trois changements : je n'ai pas ouvert de navigateur […] ». C'est donc à vous de regarder encore.

Les trois corrections se voient. Il reste un vide au-dessus de la plante tant qu'elle est jeune. Vous gardez ce défaut, ou vous faites un tour de plus.
Tour 4 : vérifier, puis commit (5 minutes)
Relancez les vérifications si le tour 3 ne l'a pas fait, et regardez une dernière fois l'écran du téléphone. Puis :
C'est bon pour moi. Fais le commit, message clair en français, ne pousse rien.
Ici, le commit a pris 48 secondes : « Crée Pousse, un minuteur de révision qui fait pousser une plante ». Contrôlez avec git log --oneline et git status.

Un tour de plus : la page s'explique-t-elle seule ?
Vous connaissez votre idée par cœur. L'agent aussi : il a lu votre fiche. La personne qui ouvre la page, elle, n'a rien lu. Montrez l'écran à quelqu'un sans rien expliquer, ou rouvrez-le comme si vous le découvriez. La page doit répondre seule à quatre questions : à quoi sert l'application, comment elle fonctionne, par où commencer, et pourquoi il se passe ce qui se passe.
« Pousse » a raté ce test. Devant une plante fanée, quelqu'un qui ne connaissait pas l'idée a dit : « On ne comprend rien à quoi sert l'application. Pourquoi elle fane ? » La page montrait un titre, un minuteur et un bouton. La règle des 60 secondes n'apparaissait qu'une fois la session lancée, et le message de la plante fanée ne la rappelait pas.
La demande reprend la remarque telle qu'elle a été dite, puis précise ce qui manque :
J'ai montré l'application à quelqu'un qui ne connaissait pas l'idée. Sa
réaction : « on comprend rien à quoi sert l'application ». Il s'est demandé
quel est le but, comment ça fonctionne, à quoi ça sert, et pourquoi la plante
fane.
Ajoute sur la page de quoi répondre à ces questions, sans rien lire ailleurs :
1. Sous le titre, une ou deux phrases qui disent à quoi sert Pousse et pour
qui.
2. Avant la première session, un court « Comment ça marche » en trois étapes
[…].
3. La règle de la fanaison, dite clairement avant de commencer, avec sa
raison : rester concentré. Elle est rappelée quand la plante a fané, pour
qu'on comprenne ce qui s'est passé.
Textes courts, en français, au tutoiement comme le reste. Rien d'autre ne
change. […] Relance les tests et le build, puis dis-moi ce que tu as vérifié
et ce que tu n'as pas vérifié. Pas de commit.
L'agent a travaillé 4 min 20. Les 60 tests étaient verts avant, ils le sont après : aucun test ne vérifie qu'une page se comprend.

Le message de la plante fanée dit maintenant ce qui s'est passé : « La plante a fané : tu as quitté l'onglet plus de 60 s. » Après un dernier regard à l'écran, un second commit a pris 11 secondes.
Les sept appels à l'agent ont pris 35 minutes en tout, pour un plan annoncé à 6 heures. Votre temps à vous sert à écrire, à répondre et à regarder.
Votre poste est prêt si l'agent a :
- lancé l'application ;
- lancé une vérification et montré sa sortie réelle ;
- montré un résultat que vous avez vu de vos yeux ;
- fait un commit quand vous l'avez demandé.
Notez chaque piège rencontré : ils entreront dans le skill de votre groupe.
2. Le kit dans le dépôt du projet 2, 5 minutes
Poser le kit
Un membre s'en charge, sur une branche :
- Il copie le contenu du kit à la racine du dépôt, dossier caché
.agents/compris. Si le dépôt a déjà unAGENTS.md, il y ajoute les sections du kit et garde les règles du projet. - Il remplit
AGENTS.md: le nom du projet, sa phrase et le tableau du groupe. La table des commandes se remplit à la partie 3, avec le skill. - Il ouvre la PR. Les autres la relisent avant la fusion.
Chacun donne la valeur de git config user.name pour sa ligne. C'est par elle que l'agent sait pour qui il travaille :
| Prénom | Nom d'auteur git (`git config user.name`) | Dossier | Travaille sur |
| --- | --- | --- | --- |
| Léa | lea-dupont | `docs/lea/` | la génération des menus |
Si aucune ligne ne correspond, AGENTS.md dit à l'agent de demander le prénom avant tout.
Avec Claude Code. Claude Code lit CLAUDE.md, et celui du kit tient en une ligne, @AGENTS.md, qui importe le fichier commun. Si votre dépôt a déjà un CLAUDE.md, ajoutez-y cette ligne au lieu de le remplacer. Claude Code ne cherche ses skills que dans .claude/skills/ : demandez-lui une fois « Copie les dossiers de .agents/skills dans .claude/skills », et la règle de AGENTS.md lui fait refaire la copie après chaque modification. La copie se commite avec l'original, dans la même PR.
Chaque membre ouvre son dossier
Après la fusion, chacun récupère main, crée sa branche et demande :
Mets en place ma bureaucratie. En ce moment je travaille sur (votre partie
du projet, en une ou deux phrases).
Ce sujet devient votre premier ticket. Lors d'un essai du kit avec un modèle gratuit, pour une étudiante nommée Léa, l'agent a trouvé son prénom par le nom d'auteur git et créé trois fichiers en 27 secondes, rien d'autre :
docs/lea/
├── STATUS.md 18 lignes, trois actions numérotées
├── tickets/LD-001-generation-menus.md cinq critères vérifiables par oui ou par non
└── journal/AAAA-MM-JJ.md
Un critère du ticket : « Un menu qui dépasse le budget n'est pas enregistré. » L'agent de Noah, à qui on demandait au passage de corriger le fichier de Léa, a créé docs/noah/ et refusé le reste : « chaque agent n'écrit que dans le dossier de la personne qu'il sert ». Votre dossier se commite sur votre branche et rejoint main par votre PR. C'est sur main que les autres lisent votre état : fusionnez souvent.
3. Le skill du groupe, 45 minutes
Le template est arrivé avec le kit : .agents/skills/ma-stack/SKILL.md. Sur une nouvelle branche, renommez le dossier et la ligne name: avec le nom de votre stack, en minuscules et avec des tirets (stack-django-htmx).
Votre version, à la main
Commencez par « Nos règles », pas par les pièges : comment vous voulez que votre code soit écrit. Une règle dit quoi faire, où, et pourquoi, avec des limites qu'on peut compter. Deux exemples de règles :
- Une route fait cinq choses au plus : valider, charger, appeler le domaine
ou un agent, enregistrer, renvoyer l'état.
- Méthodes de 15 lignes au plus : au-delà, une méthode fait plusieurs choses
et se teste mal.
Remplissez ensuite la table de la stack avec les versions lues dans vos fichiers de dépendances, puis les vérifications dans l'ordre. Écrivez la description en dernier, avec les mots que vous tapez vraiment. Faites un commit : « v1 : écrite à la main ». Le skill stack-nuxt, fourni en exemple à côté du kit, montre ce qu'un skill devient avec le temps : le détail est rangé dans un dossier references/.
Une version écrite par l'agent
Pendant ce temps, un autre membre reste sur main, où l'agent ne peut pas lire votre version. Dans Codex, le skill qui écrit des skills s'appelle skill-creator.
Écris un skill pour la stack de notre projet : (frameworks, base, bibliothèque
du modèle de langage, hébergeur). Si tu as un skill qui écrit des skills,
utilise-le.
Lis d'abord les fichiers de dépendances du dépôt pour trouver les versions
réelles. N'ouvre pas le dossier .agents/skills/ma-stack : je veux ta version.
Le skill dit comment le code doit être écrit, les vérifications dans l'ordre
et les pièges connus. Enregistre-le dans skill-agent/SKILL.md et ne fais
aucun commit.
Comparer, puis la version 2
Posez les deux versions côte à côte et cherchez :
- ce que l'agent a prévu et pas vous, souvent une version précise ou une vérification ;
- ce que vous avez prévu et pas lui, souvent votre style et vos interdits ;
- ce qui reste flou chez l'un ou l'autre, comme « un code propre » sans limite chiffrée.
La version 2 garde le meilleur des deux. L'autre membre vous envoie son fichier skill-agent/SKILL.md, puis supprime ce dossier de son clone. Vous écrivez la version 2 ensemble, sur la branche de la version à la main. Relisez-la ligne par ligne, puis faites un commit qui dit ce qui a changé et pourquoi.
Le test : une nouvelle session
Ouvrez une nouvelle session sur la branche du skill, sans rien expliquer à l'agent. Avec Claude Code, faites d'abord recopier le skill dans .claude/skills/ et supprimer l'ancienne copie ma-stack.
(Une petite tâche de votre projet 2, par exemple : ajoute la page qui liste
les réservations.) Propose un plan d'abord.
Vérifiez que l'agent annonce le skill (OpenCode affiche une ligne → Skill "…"), lit les versions réelles et cherche un fichier voisin avant d'écrire. Son plan doit suivre vos règles et prévoir vos vérifications. Si une règle n'est pas suivie, vérifiez d'abord que le bon skill est chargé. Relisez ensuite la règle : floue, vous la reformulez, absente, vous l'ajoutez. Puis un nouveau commit et un nouveau test.
Les pièges de votre application de la partie 1 sont les premières lignes de « Pièges déjà payés », au format du template : ce qu'on voit, la cause, la parade.
- **L'élément principal de l'écran est minuscule, tests et build verts** :
aucune vérification ne regarde l'écran. Regarder la page à la largeur d'un
téléphone avant de dire « fini ».
- **La page ne dit pas à quoi elle sert, tests et build verts** : l'auteur et
l'agent connaissent l'idée, pas le visiteur. Faire lire l'écran à quelqu'un
qui ne la connaît pas, puis écrire sur la page le but, le mode d'emploi et
la raison de chaque règle.
Reportez enfin vos vérifications dans la table « Commandes » de AGENTS.md, sur la même branche.
Livrable : .agents/skills/<stack>/SKILL.md, dans une PR relue par le groupe puis fusionnée dans le dépôt du projet 2. Il est relu à la revue d'avancement n° 1.
4. Le reste de la séance : votre projet
Vous reprenez votre projet 2, chacun sur sa branche, avec le kit et votre skill. Cette fin de séance met le skill à l'épreuve d'un vrai travail.
Tester, valider, améliorer le skill
- Tester : donnez à l'agent une vraie tâche de votre ticket. Regardez s'il annonce le skill et s'il suit vos règles.
- Valider : une règle qui a tenu sur deux ou trois tâches reste telle quelle.
- Améliorer : quand vous corrigez l'agent deux fois pour la même chose, la correction entre dans le skill. Un piège payé ce soir entre dans « Pièges déjà payés ».
Ajoute cette règle au skill du groupe : (la règle, et sa raison en une phrase).
Fais-le sur une branche, je relirai avant d'ouvrir la PR.
Faire travailler des sous-agents
Sur un gros ticket, vous ne distribuez pas le travail vous-mêmes. Vous dites ce que vous voulez à votre agent, et il s'organise :
Voici ce que je veux : (le besoin, en quelques phrases, et le ticket).
Fais le plan, découpe-le en lots, et montre-moi le découpage avant de lancer.
Confie ensuite chaque lot à un sous-agent, avec consignes/consigne-lot.md.
Vérifie leur travail et demande les corrections. Rends-moi un seul compte
rendu : ce qui est vérifié, ce qui ne l'est pas.
Relisez le découpage et coupez ce qui est en trop. L'agent remplit lui-même consignes/consigne-lot.md pour chaque lot, lance les sous-agents, relit ce qu'ils rendent et leur fait corriger. La dernière vérification est la vôtre : l'écran, les sorties, le diff. Vous corrigez encore, ou vous validez.
Avant de pousser ce travail, consignes/relecture-croisee.md se donne à un autre agent, de préférence un autre modèle. Il rend dix constats au plus, chacun avec un scénario concret. Son rapport va dans docs/<prénom>/relectures/, et vous répondez sous chaque constat.
Fermer la session
Une session qui se ferme emporte tout ce qui n'est pas écrit dans le dépôt. Avant de fermer, faites mettre à jour votre dossier docs/<prénom>/. Demain, vous, un autre agent ou un coéquipier reprendrez le travail à partir de ces fichiers.
J'ai fini pour aujourd'hui. Fait : (ce qui marche, et sa preuve). Pas
commencé : (…). Problème rencontré : (le problème, et ce qui l'a réglé).
Mets tout à jour.
L'agent réécrit votre STATUS.md, complète le journal du jour et met à jour le ticket. Relisez les cases qu'il a cochées. Une case se coche sur une preuve qu'il a vue, comme un test lancé ou un écran regardé, pas sur ce que vous lui racontez. Faites ensuite le commit sur votre branche.
À la session suivante, une phrase suffit pour reprendre : « Où j'en suis ? ».
Quand ça coince
| Ce que vous voyez | Ce que vous faites |
|---|---|
| Un modèle gratuit s'arrête sans rien écrire, ou répond « Unexpected server error » | Relancez avec un autre modèle gratuit (/models dans OpenCode). Confiez les grosses demandes à votre agent le plus solide. |
| L'agent ne charge pas votre skill, ou en charge un autre | Regardez ce qu'il voit : opencode debug skill dans un terminal pour OpenCode, la liste des skills de l'app pour Codex (/skills dans son terminal). Nommez le skill dans la demande. |
| Claude Code ignore le skill | Il ne lit pas .agents/skills/. Faites copier le dossier dans .claude/skills/. |
| Le port reste occupé après l'arrêt du serveur | Des processus node enfants écoutent encore. Demandez à l'agent de les arrêter par leur ligne de commande, puis de vérifier le port. |
| L'agent dit « fini » sans sortie | Redemandez les sorties réelles des vérifications et les deux listes : vérifié, pas vérifié. |
En résumé
- Votre application se fait en quatre tours : l'analyse sans code, la construction après vos réponses, la critique de l'écran, puis le commit.
- Vos yeux trouvent ce que les tests ne voient pas. L'agent dit ce qu'il n'a pas vérifié quand vous le lui demandez.
- Une page doit s'expliquer seule : son but, son mode d'emploi et la raison de ses règles. Faites-la lire à quelqu'un qui ne connaît pas votre idée.
- Le kit pose
AGENTS.md, le template du skill et un dossierdocs/<prénom>/par membre. L'agent de chacun n'écrit que dans le sien. - Le skill du groupe part de vos règles, se compare à une version écrite par l'agent, puis se teste dans une session neuve.