Vue d'ensemble

Le workflow

Un workflow, c'est la chaîne d'étapes qui transforme une idée en site en ligne. Voici celle du projet NSI : du premier prompt à l'URL publique.

Pourquoi un workflow ?

Un workflow, c'est la chaîne d'habitudes qui transforme une idée en site en ligne : quoi faire d'abord, quoi vérifier, quand s'arrêter, quand recommencer. Sans lui, on demande tout, tout de suite, on obtient un projet qui « marche » deux minutes puis qu'on ne sait plus réparer.

Avec lui, l'IA devient ce qu'elle est vraiment : un exécutant rapide et infatigable, sous la direction d'un humain qui décide et qui vérifie. Le travail change de nature — moins de frappe, plus de réflexion — mais il ne disparaît jamais.

La règle qui résume tout

L'agent produit, l'humain décide et valide. Chaque fois que vous inversez les rôles, le projet se dégrade.

La boucle : cinq temps, à chaque demande

Chaque fois que vous demandez quelque chose à l'agent, le même cycle recommence. Il est court — quelques minutes — et c'est lui qui distingue un projet maîtrisé d'un enchaînement de hasards.

DécrireGénérerTesterCorrigerLivrer
Temps 1

Décrire

Vous — Vous formulez l'objectif, le contexte, les contraintes et le critère de réussite. Vous découpez en une demande à la fois.

L'agent — Il pose des questions si quelque chose est ambigu — laissez-le faire, ses questions révèlent vos oublis.

Feu vert pour la suite : L'agent a reformulé ce qu'il allait faire, et c'est bien ce que vous voulez.

Temps 2

Générer

Vous — Vous lisez ce qui est produit : quels fichiers sont créés ou modifiés, et pourquoi. Vous ne validez pas à l'aveugle.

L'agent — Il écrit le code, crée les fichiers, propose un plan de travail.

Feu vert pour la suite : Les fichiers annoncés existent réellement et le plan vous paraît juste.

Temps 3

Tester

Vous — Vous lancez, vous ouvrez dans le navigateur, vous regardez le rendu et les erreurs.

L'agent — Il démarre le serveur, explique comment vérifier, et propose des tests si vous le demandez.

Feu vert pour la suite : Le résultat fonctionne pour de vrai — pas « ça a l'air bon ».

Temps 4

Corriger

Vous — Vous décrivez l'écart précisément : « le bouton chevauche le titre sur téléphone », pas « c'est moche ».

L'agent — Il corrige, et parfois casse autre chose : c'est à vous de re-tester ce qui marchait.

Feu vert pour la suite : Le test repasse, et rien d'autre n'a régressé.

Temps 5

Livrer

Vous — Vous committez, vous déployez, vous partagez l'URL — et vous journalisez les prompts utilisés.

L'agent — Il prépare les commandes et rédige le message de commit si vous le lui demandez.

Feu vert pour la suite : L'URL publique répond, le dépôt est à jour, les prompts sont déposés.

Le parcours du projet : cinq étapes

La boucle se répète à l'intérieur d'un parcours plus large : les cinq étapes qui font passer d'une page blanche à une adresse publique. Chacune a un critère de sortie : tant qu'il n'est pas rempli, on ne passe pas à la suivante.

Qui fait quoi

Répartir les rôles, c'est se protéger de la déception : on ne reproche pas à l'agent ce qu'il n'a jamais su faire. Voici la frontière, en deux colonnes.

Vous — non délégable
  • Choisir le sujet, le public et le message : l'IA n'a ni goût ni intention.
  • Décider ce qui est acceptable : un texte, une image, une couleur se valident.
  • Vérifier la sécurité : aucun secret dans le dépôt, aucune donnée personnelle publiée.
  • Comprendre ce qui est écrit : on ne signe pas un projet qu'on ne peut pas expliquer.
  • Publier et assumer : c'est votre nom qui est derrière l'URL.
L'agent — excellent, rapide
  • Écrire vite du code répétitif et de la structure : pages, styles, formulaires.
  • Expliquer un message d'erreur, un fichier, une commande.
  • Proposer des variantes quand on est bloqué sur un choix.
  • Exécuter des tâches longues et minutieuses : renommer, réorganiser, vérifier.
  • Traduire une intention en étapes techniques — quand l'intention est claire.
La ligne rouge

Quatre choses ne se délèguent jamais : choisir ce qu'on publie, protéger les secrets, les données personnelles et la compréhension du projet. Un travail que vous ne pouvez pas expliquer n'est pas votre travail.

Un exemple complet, du premier prompt à l'URL

Voici comment la boucle et le parcours s'enchaînent sur un vrai cas : une page d'accueil sur les abeilles. Tout ce qui suit, vous pouvez le refaire.

  1. Décrire

    Cadrer le projet avant de coder

    Tu vas m'aider à construire une page d'accueil sur les abeilles. Avant de coder : pose-moi 5 questions pour préciser le sujet, le public et le style. Ne crée aucun fichier.

    L'agent pose des questions, l'élève répond. À la fin, on sait quoi construire — et on a déjà évité deux malentendus.

    💡 Un projet qui commence par des questions coûte moins cher qu'un projet qui commence par du code.

  2. Décrire

    Demander une seule chose à la fois

    Crée une page d'accueil avec : un titre, un paragraphe de présentation, une image d'abeille et un bouton « En savoir plus ». Explique-moi chaque fichier que tu crées.

    Les fichiers sont créés, et l'explication permet de comprendre où vit quoi.

  3. Tester

    Lancer et regarder

    Comment je lance le site pour le voir dans mon navigateur ?

    Une erreur apparaît au démarrage. L'élève copie le message d'erreur dans la conversation — c'est la meilleure façon de demander de l'aide.

  4. Corriger

    Corriger avec le message d'erreur, pas avec des suppositions

    Voici l'erreur complète quand je lance le serveur : [message]. Explique ce qu'elle veut dire, puis corrige.

    L'agent explique, corrige, le serveur démarre. La page s'affiche.

    💡 Coller l'erreur ENTIÈRE fait gagner des dizaines de minutes : elle contient le fichier et la ligne.

  5. Livrer

    Enregistrer un premier point de retour

    Prépare les commandes Git pour enregistrer cette première version, et explique chaque commande.

    Premier commit : la page d'accueil existe et l'historique commence. C'est le point de retour en cas de bêtise.

    💡 Une étape terminée = un commit. Ce n'est pas du rangement, c'est une assurance.

  6. Tester

    Améliorer… puis casser

    Ajoute une section « Pourquoi les abeilles sont essentielles » et change les couleurs.

    La nouvelle section s'affiche, mais le CSS casse l'ancienne. C'est normal : chaque modification peut casser ce qui marchait.

    💡 Le réflexe est de re-tester TOUTE la page, pas seulement la nouveauté.

  7. Corriger

    Revenir en arrière plutôt que s'enliser

    Le bouton chevauche le titre sur téléphone. Compare avec la version du commit précédent si nécessaire.

    Soit l'agent corrige et on vérifie, soit on restaure le dernier commit (git restore) et on repart d'une base saine. Dans les deux cas, on ne reste pas bloqué.

    💡 Un commit qui fonctionne vaut mieux qu'une heure de corrections empilées.

  8. Livrer

    Publier et partager

    Explique-moi les étapes pour publier ce projet sur Cloudflare Pages, et ce que je dois vérifier avant.

    Le site est déployé à une URL publique. On vérifie qu'elle répond, puis on envoie le lien.

    💡 Avant de publier : la checklist de la section Sécurité.

  9. Livrer

    Journaliser les prompts

    Aide-moi à résumer les prompts qui ont mené à cette version.

    Les prompts sont déposés sur le site du projet avec le code anonyme. C'est la trace du travail : ce que l'élève a demandé, compris et corrigé.

    💡 Le journal des prompts raconte la vraie histoire du projet — bien mieux qu'un fichier final.

Les règles du jeu

  1. Une demande = un objectif. Deux objectifs dans un même prompt, c'est deux fois plus de chances de tout casser.
  2. Toujours lire avant de valider : ce que vous acceptez sans lire devient votre responsabilité.
  3. Tester après chaque modification, même petite : le rendu, pas l'impression.
  4. Committer avant les grosses demandes : un commit est un point de retour.
  5. Journaliser les prompts : sans trace, le travail devient invisible.
  6. Ne jamais publier un secret : le dépôt, les prompts et les captures ne sont pas des coffres-forts.

Quatre idées fausses à jeter

« L'IA fait tout, je n'ai qu'à attendre. »

L'agent produit très vite, mais il ne sait pas ce qu'il doit obtenir. Sans direction ni vérification, il livre du code qui a l'air fini et ne fonctionne pas.

« Un bon prompt règle tout du premier coup. »

Le premier jet est un brouillon. Le travail réel est la boucle : tester, décrire l'écart, corriger. C'est là qu'on apprend.

« Le code généré est forcément correct. »

Un modèle prédit du texte plausible : il peut inventer une fonction, une bibliothèque, une commande. La vérification n'est pas optionnelle.

« Ça marche sur ma machine, donc c'est fini. »

Un site fini répond à une URL publique, sur un autre poste, et son dépôt contient tout ce qu'il faut pour le reconstruire.

Quatre prompts à réutiliser

Ils ne sont pas magiques : ils sont précis. Copiez-les, puis adaptez le sujet — jamais l'inverse.

Cadrer
Avant de coder, pose-moi les questions nécessaires pour bien comprendre ce que je veux. Ne crée aucun fichier pour l'instant.
Faire expliquer
Explique-moi ce que tu viens de faire, fichier par fichier, comme si je débutais. Signale ce que je devrais vérifier moi-même.
Corriger
Voici le comportement attendu : […]. Voici ce qui se passe : […]. Voici le message d'erreur complet : […]. Propose une correction et explique-la.
Revenir en arrière
La dernière modification a cassé […]. Montre-moi comment revenir au dernier état qui fonctionnait, sans perdre le reste.

La promptothèque complète — classée par intention, avec les explications — vit dans la section Promptothèque.

Pour aller plus loin