Cours Vibe coding avec Claude Code · Module 3: Clone de Twitter

L'œil du second : lire un diff et /code-review

9 min de lecture ·
Dans cette leçon11

Le rat de la leçon 2_8 est passé par le build, par le lint et par ta revue parce que le changement tenait en quelques caractères et se trouvait dans le diff à côté du badge que tu avais demandé. Tu lisais ce code à travers la conversation où tu avais demandé le badge, et Claude aussi. La documentation de Claude Code a un conseil : que le code soit regardé par quelqu'un qui ne l'a pas écrit. La commande /code-review lance un relecteur dans un sous-agent tout neuf, qui n'a pas vu votre conversation et ne cède donc pas au raisonnement dont le code est né. Aujourd'hui tu vas faire passer par une telle revue une nouvelle fonction du formulaire, avant qu'elle n'arrive dans un commit.

Une fonction sur une branche à part

Le capitaine écrit beaucoup, donc il veut envoyer un post au clavier, sans toucher à la souris. Tu pars d'une liste propre dans Source Control et d'une nouvelle branche de la leçon 1_5 : demande à Claude la branche feature/ctrl-enter, et dans la demande d'autorisation tu verras git switch -c feature/ctrl-enter. Sur main reste la version qui marche, et la branche servira aussi au relecteur, on y vient.

Demande pour Claude Code :

Dans @components/Feed.tsx : Ctrl+Entrée (sur Mac aussi Cmd+Entrée)
dans le champ du post envoie le post comme le bouton Envoyer. Entrée
seule continue de passer à la ligne. Ne change rien d'autre. À la
fin, npm run build et npm run lint.

La demande nomme le fichier, le comportement et la limite. La phrase sur Entrée seule protège ce que les joueurs connaissent déjà, et « ne change rien d'autre » sera la mesure quand tu liras le diff.

Ce que Claude a écrit

Dans components/Feed.tsx, le champ <textarea> a reçu une gestion du clavier :

onKeyDown={(e) => {
  if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
    e.preventDefault();
    e.currentTarget.form?.requestSubmit();
  }
}}

onKeyDown réagit à l'appui sur une touche. e.ctrlKey et e.metaKey disent si tu tiens Ctrl ou Cmd avec Entrée, et preventDefault() bloque le retour à la ligne dans le champ. requestSubmit() envoie le formulaire comme si quelqu'un avait cliqué sur le bouton d'envoi, donc il déclenche le même handleSubmit. Le ?. est ici honnête, car le champ de texte n'est pas forcément dans un formulaire, et form est alors vide.

Lire un diff dans Cursor

Ouvre Source Control. Tu lis le diff d'en haut : d'abord la liste des fichiers, ensuite chaque fichier à part. La liste parle de l'étendue avant que tu aies lu une seule ligne : tu as demandé un changement dans un fichier, et la liste en compte deux, Feed.tsx et LikeButton.tsx. Clique sur le second :

-      className="mt-3 text-sm text-gray-500 hover:text-red-600"
+      className="mt-3 text-sm font-semibold text-gray-500 hover:text-red-600"

Claude a mis « au passage » le bouton J'aime en gras, sans doute pour qu'il aille avec le bouton Envoyer. Le changement a l'air innocent, mais il ne découle pas de la tâche : il mélange deux affaires dans un seul commit et change une apparence que personne n'a demandée. Dans chaque fichier de la liste, tu cherches trois choses : des lignes que la tâche ne demande pas, des lignes supprimées que tu n'attendais pas, et les trucs de la leçon 2_8, comme eslint-disable. La commande /diff de la session montre aussi les mêmes changements.

Rejeter un changement hors périmètre

/rewind annulerait toute la demande, donc aussi la gestion de Ctrl+Entrée. Ici il te faut une corde pour un seul fichier, connue de la leçon 1_5 :

! git restore components/LikeButton.tsx

git restore rejette les modifications d'un fichier que tu n'as pas encore ajoutées à un commit, et le point d'exclamation lance la commande directement depuis la session. Dans la liste de Source Control il ne reste que Feed.tsx. Tu peux aussi écrire à Claude « Annule la modification de LikeButton.tsx, elle n'était pas dans la tâche » et voir la même commande dans la demande d'autorisation. Retiens : Claude aime améliorer les alentours, et plus la demande est étroite, plus c'est facile à repérer.

/code-review : des yeux neufs

Maintenant la revue. Écris dans la session :

/code-review

Sans argument, /code-review examine les commits de ta branche qui ne sont pas encore dans son équivalent sur GitHub, ainsi que les changements non enregistrés dans un commit. La branche feature/ctrl-enter n'a pas encore d'équivalent, donc Claude la compare avec main : la revue ne couvrira que ta modification non enregistrée. Sur main avec plusieurs commits non envoyés, elle les couvrirait tous. Dans le terminal, la revue tourne en arrière-plan, dans un sous-agent avec son propre contexte, et les résultats arrivent dans la conversation quand ils sont prêts. Le relecteur cherche des bugs de fonctionnement, lit ton CLAUDE.md et, sans l'option --fix, ne change rien, il rédige seulement un rapport. Claude peut aussi lancer la revue lui-même quand tu le demandes simplement : « fais une revue de mes changements ».

Ce qu'a trouvé le relecteur

Ton rapport aura d'autres mots, mais une forme semblable :

components/Feed.tsx : Ctrl+Entrée contourne la limite de 280
caractères. requestSubmit() envoie le formulaire même quand le
bouton Envoyer est désactivé, et handleSubmit ne vérifie que
l'absence de texte. Un post de plus de 280 caractères arrive
sur le fil.

Une trouvaille est une hypothèse, comme dans la leçon 2_8, donc tu la vérifies avant d'y croire. Colle dans le champ plus de 280 caractères : le compteur devient rouge et le bouton est désactivé. Appuie sur Ctrl+Entrée, et le post trop long atterrit quand même sur le fil. Le bouton n'était que le verrou de la porte, et le raccourci clavier est entré par la fenêtre. Trouvaille confirmée.

Corriger la trouvaille

Tu commandes la correction dans la conversation, par une seule demande étroite :

Corrige la trouvaille de la revue : handleSubmit dans
@components/Feed.tsx doit rejeter un post vide et un post plus long
que MAX_LENGTH, comme le bouton. Rien d'autre. Ensuite npm run lint
et npx tsc --noEmit.

Le diff contient une ligne modifiée au début de handleSubmit :

if (!draft.trim() || draft.length > MAX_LENGTH) return;

La règle « un post vide ou trop long ne passe pas » habite maintenant là où le formulaire est vraiment envoyé, et le bouton désactivé reste un indice pour l'œil. Refais l'essai avec 300 caractères : Ctrl+Entrée n'ajoute rien, et un post court s'envoie au clavier comme il faut.

Pourquoi pas /code-review --fix ? Avec cette option, le relecteur introduit lui-même les corrections, et quand il tourne en arrière-plan, ses modifications contournent les checkpoints de la session : /rewind n'annule que les fichiers que Claude avait modifiés plus tôt dans la conversation, et le reste ne s'annule plus que par Git. Pour commencer, je te conseille la voie du rapport : tu lis les trouvailles, tu les vérifies et tu commandes les corrections une par une.

/simplify n'est pas /code-review

À côté de la revue, il y a une seconde commande au nom voisin. /simplify parcourt le code modifié pour le ranger : répétitions, simplifications, performance et niveau d'abstraction, et applique tout de suite les corrections. Elle ne cherche pas les bugs de fonctionnement ; la documentation renvoie pour cela à /code-review. Dans de vieux tutoriels les deux noms se mélangent, car autrefois /simplify désignait la revue d'aujourd'hui. Avant le commit d'une fonction, il te faut le chasseur de bugs, c'est-à-dire /code-review.

Quand faire le commit

Tu fais le commit quand tu réponds « oui » à chacune de ces questions :

  1. Dans la liste de Source Control, il n'y a que les fichiers de la tâche.
  2. Tu as lu le diff de chacun d'eux.
  3. Chaque trouvaille de la revue est corrigée ou rejetée en connaissance de cause, avec la raison.
  4. npm run build, npm run lint et npx tsc --noEmit passent, et tu as vu toi-même les résultats.
  5. La fonction marche dans le navigateur, y compris dans le cas qu'a indiqué le relecteur.

Puis une seule demande, connue de la leçon 1_8 : un commit avec une description du genre « Ctrl+Entrée envoie le post, limite de 280 aussi dans handleSubmit », la fusion de feature/ctrl-enter dans main et git push, avec les commandes montrées avant d'être lancées.

La revue du capitaine

Les erreurs typiques de la revue, tu les repères à trois symptômes :

  1. Des corrections sans questions. Claude se jette sur chaque trouvaille pour la corriger. Le relecteur aussi peut se tromper, donc pour une trouvaille douteuse, demande les étapes qui montrent le problème.
  2. Une revue vide comme preuve. Un rapport sans trouvailles ne veut pas dire que la fonction marche. La preuve reste le build, le lint et une promenade dans l'application.
  3. Un commit avec du lest. Un fichier hors périmètre est resté dans la liste, parce que personne n'a lu la liste des fichiers avant le commit.

Étape suivante

La messagerie est prête pour la première revue du mentor : routes, composants, état, enregistrement dans localStorage, CLAUDE.md avec les conventions et un historique de petits commits. Envoie le lien du dépôt dans la tâche à la fin du lieu. Dans le lieu suivant, tu construiras un clone d'Instagram et feras passer chacune de ses fonctions par la même boucle, avec une revue avant le commit. Dans l'éditeur ci-dessous t'attend le formulaire de cette leçon avec un interrupteur de correction : colle un long post et compare ce que fait Ctrl+Entrée avant la revue et après.

Retiens : le second, qui n'a pas entendu le conseil de guerre, voit le récif que le capitaine ne voit plus.

Code de cette leçon : App.jsx
// Ctrl+Entrée (sur Mac Cmd+Entrée) envoie le post.
// Colle plus de 280 caractères : le bouton Envoyer se désactive.
// Sans la correction de la revue, Ctrl+Entrée envoie quand même un post trop long.
import { useState } from 'react';

const MAX_LENGTH = 280;

export default function App() {
  const [posts, setPosts] = useState([]);
  const [draft, setDraft] = useState('');
  const [reviewFix, setReviewFix] = useState(false);

  const handleSubmit = (e) => {
    e.preventDefault();
    if (!draft.trim()) return;
    // Correction de la trouvaille de /code-review : la limite est vérifiée aussi ici
    if (reviewFix && draft.length > MAX_LENGTH) return;

    setPosts([{ id: String(Date.now()), content: draft.trim() }, ...posts]);
    setDraft('');
  };

  const tooLong = draft.length > MAX_LENGTH;

  return (
    <div className="min-h-screen bg-gray-50 p-6 text-gray-900">
      <h1 className="text-3xl font-bold">Formulaire de post</h1>

      <label className="mt-4 flex items-center gap-2 text-sm">
        <input type="checkbox" checked={reviewFix} onChange={(e) => setReviewFix(e.target.checked)} />
        Correction de la revue : limite aussi dans handleSubmit
      </label>

      <form onSubmit={handleSubmit} className="mt-4 rounded-lg border border-gray-300 bg-white p-4">
        <textarea
          value={draft}
          onChange={(e) => setDraft(e.target.value)}
          onKeyDown={(e) => {
            if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) {
              e.preventDefault();
              e.currentTarget.form?.requestSubmit();
            }
          }}
          rows={4}
          placeholder="Écris un post et appuie sur Ctrl+Entrée"
          className="w-full rounded border border-gray-300 p-2"
        />
        <div className="mt-2 flex items-center justify-between">
          <span className={tooLong ? 'text-sm text-red-600' : 'text-sm text-gray-500'}>
            {draft.length}/{MAX_LENGTH}
          </span>
          <button
            type="submit"
            disabled={!draft.trim() || tooLong}
            className="rounded bg-blue-600 px-4 py-2 font-semibold text-white disabled:opacity-50"
          >
            Envoyer
          </button>
        </div>
      </form>

      <ul className="mt-4 space-y-2">
        {posts.map((post) => (
          <li key={post.id} className="rounded border border-gray-300 bg-white p-3">
            <span className={post.content.length > MAX_LENGTH ? 'font-bold text-red-600' : 'text-gray-500'}>
              {post.content.length} caractères :
            </span>{' '}
            {post.content.slice(0, 60)}
          </li>
        ))}
      </ul>
    </div>
  );
}

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Qu'examine /code-review écrit sans argument ?

  2. 2. Tu as demandé Ctrl+Entrée dans Feed.tsx, et dans Source Control tu vois aussi une classe modifiée dans LikeButton.tsx. Que fais-tu avant le commit ?

Voici 2 des 3 questions de cette leçon. Réponds aux autres dans le jeu.

  1. QuestionCe que relit /code-review sans argument
  2. QuestionUn changement hors périmètre dans le diff
  3. Question/code-review ou /simplify
  4. Projet à envoyerEnvoie Kraken's Call au mentor
  5. VidéoRésumé du module

Articles utiles