Cours Vibe coding avec Claude Code · Module 12: Clone de Medium

L'éditeur de chronique : plan, blocs et sauvegarde automatique

11 min de lecture
Dans cette leçon9

Ohé ! Le capitaine tient son journal depuis des années, mais les pages prennent l'eau et les récits de voyage se perdent au fond d'un coffre. L'équipage veut lire ses histoires en ligne : dans cette location, tu construis donc Captain's Chronicle, un clone de Medium, la plateforme des textes longs. Tu commences par l'éditeur, car une chronique n'est pas un message de trois phrases. Elle a un titre, des paragraphes, des intertitres et des citations, et le capitaine l'écrit pendant des heures. Si l'onglet du navigateur se ferme après une heure d'écriture, le texte ne doit pas disparaître.

Ce que tu vas apprendre

  • commander une grande fonctionnalité en mode plan et relire le plan avant que le code n'existe ;
  • lire dans Cursor les types de blocs et les fonctions qui modifient une liste sans deviner ;
  • trouver une sauvegarde automatique qui ne sauvegarde jamais, et prouver le correctif avec un test à horloge simulée ;
  • surveiller les nouvelles dépendances avec une seule ligne dans CLAUDE.md.

Nouveau port : le projet captains-chronicle

La chronique est une application à part : tu la crées donc avec la commande de la leçon 1_2, en changeant seulement le nom. Compare la commande avec celle-ci avant de cliquer sur Yes :

npx create-next-app@latest captains-chronicle --ts --eslint --tailwind --app --no-src-dir --no-cache-components --agents-md --no-agent-feedback --use-npm

Ensuite, la boucle habituelle : une session claude dans le dossier captains-chronicle, un CLAUDE.md qui importe @AGENTS.md (leçon 1_7), Vitest avec le correctif @types/node de la leçon 4_1 et un premier commit. Dans la section des conventions de CLAUDE.md, ajoute une ligne, car un éditeur de texte est l'endroit où un agent aime aller chercher un paquet tout fait :

- Nouvelles dépendances seulement avec mon accord : demande avant d'ajouter un paquet à package.json.

Un éditeur prêt à l'emploi venu de npm, ce sont des centaines de lignes de code étranger, un format de sauvegarde à lui et des mises à jour que tu n'avais pas prévues. Ça peut être un bon choix, mais ce doit être ta décision, pas l'effet secondaire d'une seule commande.

Demande pour Claude Code

Un article est une liste de blocs : un paragraphe, un titre ou une citation. Chaque bloc a un identifiant, un type et un texte. Cette étape touche les types, les fonctions, un composant, une page et un hook, c'est-à-dire une fonction de React avec son propre état, donc tu commences par un plan, comme dans la leçon 1_6. En mode plan, Claude lit le projet et écrit un plan, mais ne modifie aucun fichier tant que tu ne l'as pas approuvé. À la fin, on trouve le critère de fin de la leçon 10_1.

Demande pour Claude Code :

/plan Ajoute à Captain's Chronicle un éditeur d'articles sur la page
/ecrire. Un article est une liste de blocs : paragraph, heading, quote ;
un bloc a un id, un type et un texte. Les types dans types/article.ts,
les fonctions de blocs dans lib/blocks.ts, le composant
components/ArticleEditor.tsx. Au-dessus du titre, le temps de lecture
(200 mots par minute). Sauvegarde automatique du brouillon dans
localStorage toutes les 30 secondes, y compris quand j'écris sans
pause. Aucun nouveau paquet. Propose le découpage en fichiers et
l'ordre des étapes, pas encore de code.
Ce sera fini quand les tests Vitest montrent : un article vide fait
0 minute, un nouveau bloc arrive juste après le bloc indiqué, la
sauvegarde enregistre après 30 secondes d'écriture continue. Puis
npm run lint, npx tsc --noEmit et npm run build.

Dans le plan, vérifie deux choses : d'où le bloc tire son identifiant, et ce qui redémarre l'horloge de la sauvegarde. Si le plan n'en dit rien, appuie sur Ctrl+G, qui ouvre le plan dans l'éditeur, et complète-le, ou choisis "No, keep planning" et pose la question. Quand le plan te convient, choisis "Yes, manually approve edits" : tu verras chaque modification avant qu'elle soit enregistrée.

Ce que Claude a écrit : les types de blocs

Ouvre types/article.ts dans Cursor. Le type d'un bloc est l'un de trois noms, donc une faute de frappe comme "qoute" ne passe pas le compilateur :

// types/article.ts
export type BlockType = "paragraph" | "heading" | "quote";

export interface ArticleBlock {
  id: string;
  type: BlockType;
  text: string;
}

Plus bas dans le même fichier se trouve Draft, c'est-à-dire l'identifiant, le titre et la liste des blocs. Un brouillon enregistré dans le navigateur reçoit en plus une date de sauvegarde :

// types/article.ts
export interface SavedDraft extends Draft {
  savedAt: string; // "2026-11-15T09:30:00.000Z" : JSON transforme Date en chaîne
}

savedAt est une chaîne, car selon MDN JSON.stringify transforme une date en texte au format ISO, et JSON.parse n'en refera pas une date tout seul. Tu connais ce piège depuis la leçon 2_3 : le type Date dans des données lues dans localStorage ment, et TypeScript ne le détecte pas.

Ce que Claude a écrit : des blocs sans deviner

Ouvre lib/blocks.ts. Chaque nouveau bloc reçoit son identifiant du navigateur :

// lib/blocks.ts
export function newBlock(type: BlockType = "paragraph"): ArticleBlock {
  return { id: crypto.randomUUID(), type, text: "" };
}

crypto.randomUUID() renvoie un identifiant aléatoire de 36 caractères. La documentation de React le recommande, pour des données créées localement, comme source de clés de liste. MDN ajoute une condition : il ne fonctionne que dans un contexte sécurisé, c'est-à-dire en HTTPS ou sur localhost. L'insertion après un bloc donné construit un nouveau tableau à partir de trois morceaux :

// lib/blocks.ts
export function addBlockAfter(blocks: ArticleBlock[], afterId: string, block: ArticleBlock): ArticleBlock[] {
  const index = blocks.findIndex((b) => b.id === afterId);
  if (index === -1) return [...blocks, block];
  return [...blocks.slice(0, index + 1), block, ...blocks.slice(index + 1)];
}

slice copie la partie de la liste avant le point d'insertion et la partie après, donc l'ancien tableau reste intact et React en reçoit un nouveau. Quand aucun bloc n'a cet id, le nouveau va à la fin au lieu de disparaître. Le temps de lecture compte les mots de tous les blocs :

// lib/blocks.ts
export function readingTime(blocks: ArticleBlock[]): number {
  const words = blocks.flatMap((b) => b.text.split(/\s+/)).filter(Boolean).length;
  return Math.ceil(words / WORDS_PER_MINUTE);
}

split(/\s+/) découpe le texte aux espaces et aux fins de ligne, et filter(Boolean) jette les morceaux vides. Sans ce filtre, un bloc vide compte pour un mot, car "".split(" ") donne un tableau avec une chaîne vide, et un nouvel article affiche "1 min de lecture". Math.ceil arrondit vers le haut : 201 mots font donc 2 minutes.

Ce que Claude a écrit : l'éditeur

components/ArticleEditor.tsx garde l'état, donc il commence par la directive de la leçon 2_3 :

// components/ArticleEditor.tsx
"use client";

import { useState } from "react";

La documentation de React dit que 'use client' doit se trouver tout au début du fichier, au-dessus des imports ; seuls les commentaires peuvent passer avant. Voici la modification du texte d'un seul bloc :

// components/ArticleEditor.tsx
function updateText(id: string, text: string) {
  setBlocks((prev) => prev.map((b) => (b.id === id ? { ...b, text } : b)));
}

prev => ... est une fonction de mise à jour : elle reçoit la liste de blocs la plus récente, et non celle mémorisée au dernier rendu. La documentation de React montre la différence avec un compteur : trois fois setAge(age + 1) dans une même fonction donnent 43 et non 45, car chaque appel voit le même ancien état. Le champ de texte d'un bloc a ces classes :

// components/ArticleEditor.tsx
className={`w-full resize-none rounded outline-hidden focus:bg-amber-50 ${BLOCK_STYLES[block.type]}`}

outline-hidden est, dans Tailwind 4, le successeur de l'ancien outline-none : il cache le contour du focus, mais le laisse en mode couleurs forcées du système. La documentation de Tailwind recommande alors un style de focus à toi, d'où focus:bg-amber-50. En version 4, outline-none règle outline-style: none et retire le contour à tout le monde.

Une sauvegarde automatique qui ne sauvegarde jamais

La première sauvegarde écrite par l'agent a l'air innocente. Ouvre hooks/useAutosave.ts :

// hooks/useAutosave.ts (version de l'agent)
useEffect(() => {
  const id = setTimeout(() => {
    setSavedAt(saveDraft(draft).savedAt);
  }, AUTOSAVE_MS);
  return () => clearTimeout(id);
}, [draft]);

Chaque touche modifie draft, donc React nettoie l'ancienne horloge et en lance une nouvelle pour 30 secondes pleines. C'est le debounce de la leçon 3_5 : bon pour une recherche qui attend le silence, mauvais pour une sauvegarde, car quand on écrit sans arrêt le silence n'arrive jamais. Chez nous, cette version a passé lint et tsc. Seul un test à horloge simulée l'a attrapée, avec une fonction draft(text) qui construit un brouillon d'un seul bloc :

// hooks/useAutosave.test.ts
test("sauvegarde après 30 s, même si le capitaine écrit sans pause", () => {
  const { rerender } = renderHook(({ d }) => useAutosave(d), { initialProps: { d: draft("A") } });
  let text = "A";
  for (let second = 1; second <= 31; second++) {
    text += "h";
    rerender({ d: draft(text) });
    act(() => vi.advanceTimersByTime(1000));
  }
  expect(loadDrafts()).toHaveLength(1);
  expect(loadDrafts()[0].blocks[0].text).toBe("A" + "h".repeat(30));
});

vi.useFakeTimers() dans beforeEach remplace les horloges, et selon la documentation de Vitest vi.advanceTimersByTime(1000) exécute chaque minuteur dont l'échéance tombe dans les millisecondes données. La boucle représente 31 secondes d'écriture, une lettre par seconde. La version de l'agent a échoué avec le message expected [] to have a length of 1 but got +0. Le "correctif" tentant, setInterval avec un tableau de dépendances vide, a échoué sur la deuxième ligne avec un message qui commence par expected 'A' to be 'Ahhh : l'horloge avait mémorisé le brouillon du premier rendu, et lint n'a donné qu'un avertissement react-hooks/exhaustive-deps. Cette version-ci a passé :

// hooks/useAutosave.ts
const saveIfChanged = useEffectEvent(() => {
  const json = JSON.stringify(draft);
  if (json === lastSaved.current) return;
  lastSaved.current = json;
  setSavedAt(saveDraft(draft).savedAt);
});

useEffect(() => {
  const id = setInterval(() => saveIfChanged(), AUTOSAVE_MS);
  return () => clearInterval(id);
}, []);

useEffectEvent est un hook de React pour la logique qui doit voir les props et l'état les plus récents sans redémarrer l'effet. La documentation le montre justement avec setInterval. L'horloge démarre une fois et toutes les 30 secondes enregistre le brouillon courant s'il a changé depuis la dernière sauvegarde ; lastSaved est un useRef avec le texte de la sauvegarde précédente. localStorage n'apparaît que dans cette horloge, jamais pendant le rendu, car il n'existe pas lors du rendu sur le serveur.

La revue du capitaine

  1. Identifiants. Cherche Date.now dans le projet (Cmd+Shift+F). L'agent aime id: Date.now().toString() : chez nous, cinq appels dans une même boucle ont donné cinq fois le même numéro. Deux blocs avec un seul id sont modifiés ensemble par updateText.
  2. Mises à jour fonctionnelles. Chaque setBlocks( de l'éditeur contient prev =>.
  3. Chronique vide. Un nouvel article affiche "0 min de lecture", pas "1 min".
  4. Directive. Si Claude met "use client" sous les imports, le build échoue avec The "use client" directive must be placed before other expressions.
  5. Dépendances. Dans le panneau Source Control, ouvre package.json. Un paquet d'éditeur ajouté sans demander enfreint la règle de CLAUDE.md : demande à Claude pourquoi il en veut un, ou annule-le avec /rewind de la leçon 0_6.

La dernière preuve se récolte dans le navigateur : npm run dev, la page /ecrire, écris sans pause, et au bout d'une demi-minute "enregistré à" avec l'heure apparaît sous le titre. Chez nous, c'était le cas, et dans localStorage se trouvait un brouillon avec savedAt sous forme de chaîne.

Étape suivante

Quand les tests et le navigateur sont d'accord, demande un commit "Éditeur à blocs avec sauvegarde automatique". Puis une petite demande, encore avec un plan : "Entrée à la fin d'un bloc crée un nouveau paragraphe dessous. D'abord un plan." La liste des brouillons enregistrés, qui lit localStorage selon le schéma de la leçon 2_3, t'attend dans l'exercice pratique. Dans l'éditeur ci-dessous se trouve l'éditeur en miniature avec une horloge simulée : écris sans pause et bascule sur la version de l'agent, tu verras son compte à rebours revenir sans cesse à 30.

Retiens ceci : le capitaine ne cloue pas une planche sans plan du navire, et le journal de bord doit s'écrire en pleine tempête, pas seulement quand le vent est tombé.

Code de cette leçon : App.jsx
// Éditeur de chronique en miniature : blocs, temps de lecture et sauvegarde automatique avec une horloge simulée
import { useEffect, useReducer } from 'react';

const AUTOSAVE_S = 30;
const WORDS_PER_MINUTE = 200;
const LABELS = { paragraph: 'Paragraphe', heading: 'Titre', quote: 'Citation' };
const STYLES = {
  paragraph: 'text-base',
  heading: 'text-xl font-bold',
  quote: 'border-l-4 border-gray-300 pl-3 italic',
};

let nextId = 1;
function newBlock(type = 'paragraph') {
  return { id: 'b' + nextId++, type, text: '' };
}

function addBlockAfter(blocks, afterId, block) {
  const index = blocks.findIndex((b) => b.id === afterId);
  if (index === -1) return [...blocks, block];
  return [...blocks.slice(0, index + 1), block, ...blocks.slice(index + 1)];
}

function countWords(blocks) {
  return blocks.flatMap((b) => b.text.split(/\s+/)).filter(Boolean).length;
}

function readingTime(blocks) {
  return Math.ceil(countWords(blocks) / WORDS_PER_MINUTE);
}

function formatClock(s) {
  return Math.floor(s / 60) + ':' + String(s % 60).padStart(2, '0');
}

const initialState = {
  title: '',
  blocks: [newBlock()],
  now: 0, // secondes de l'horloge simulée
  lastChange: null, // seconde de la dernière modification du texte
  savedJson: null,
  saves: [],
  agentBug: false,
  typing: false,
};

function snapshot(state) {
  return JSON.stringify({ title: state.title, blocks: state.blocks });
}

function changeText(state, blocks, title) {
  return { ...state, blocks, title, lastChange: state.now };
}

// Le reducer voit toujours l'état le plus récent, donc l'horloge ne mémorise pas un ancien brouillon
function reducer(state, action) {
  switch (action.type) {
    case 'title':
      return changeText(state, state.blocks, action.value);
    case 'text':
      return changeText(state, state.blocks.map((b) => (b.id === action.id ? { ...b, text: action.value } : b)), state.title);
    case 'type':
      return changeText(state, state.blocks.map((b) => (b.id === action.id ? { ...b, type: action.value } : b)), state.title);
    case 'add':
      return changeText(state, addBlockAfter(state.blocks, action.id, newBlock()), state.title);
    case 'agentBug':
      return { ...state, agentBug: action.value };
    case 'typing':
      return { ...state, typing: action.value };
    case 'tick': {
      let next = { ...state, now: state.now + 1 };
      if (state.typing) {
        const last = next.blocks[next.blocks.length - 1];
        next = changeText(next, next.blocks.map((b) => (b.id === last.id ? { ...b, text: b.text + (b.text ? ' ' : '') + 'vague' } : b)), next.title);
      }
      const changed = next.lastChange !== null && snapshot(next) !== next.savedJson;
      // Version de l'agent : horloge depuis la dernière touche (debounce). Correctif : toutes les 30 s depuis le départ.
      const due = next.agentBug ? next.now - next.lastChange >= AUTOSAVE_S : next.now % AUTOSAVE_S === 0;
      if (changed && due) {
        return {
          ...next,
          savedJson: snapshot(next),
          saves: [{ at: next.now, words: countWords(next.blocks) }, ...next.saves].slice(0, 4),
        };
      }
      return next;
    }
    default:
      return state;
  }
}

export default function App() {
  const [state, dispatch] = useReducer(reducer, initialState);
  const [fast, setFast] = useReducer((v) => !v, false);

  useEffect(() => {
    const id = setInterval(() => dispatch({ type: 'tick' }), fast ? 200 : 1000);
    return () => clearInterval(id);
  }, [fast]);

  const minutes = readingTime(state.blocks);
  const secondsLeft = state.agentBug
    ? state.lastChange === null
      ? AUTOSAVE_S
      : AUTOSAVE_S - (state.now - state.lastChange)
    : AUTOSAVE_S - (state.now % AUTOSAVE_S);

  return (
    <div className="min-h-screen bg-gray-50 p-4 text-gray-900">
      <div className="mx-auto max-w-xl space-y-3 rounded-xl bg-white p-4 shadow-sm">
        <p className="text-sm text-gray-500">{minutes} min de lecture · {countWords(state.blocks)} mots</p>
        <input
          aria-label="Titre"
          value={state.title}
          onChange={(e) => dispatch({ type: 'title', value: e.target.value })}
          placeholder="Titre de la chronique"
          className="w-full rounded text-2xl font-bold outline-hidden focus:bg-amber-50"
        />
        {state.blocks.map((block) => (
          <div key={block.id} className="space-y-1">
            <div className="flex gap-2 text-sm">
              <select
                aria-label="Type de bloc"
                value={block.type}
                onChange={(e) => dispatch({ type: 'type', id: block.id, value: e.target.value })}
                className="rounded border border-gray-300 px-1"
              >
                {Object.entries(LABELS).map(([type, label]) => (
                  <option key={type} value={type}>{label}</option>
                ))}
              </select>
              <button type="button" onClick={() => dispatch({ type: 'add', id: block.id })} className="text-gray-600">
                + bloc
              </button>
            </div>
            <textarea
              aria-label={LABELS[block.type]}
              value={block.text}
              onChange={(e) => dispatch({ type: 'text', id: block.id, value: e.target.value })}
              rows={block.type === 'heading' ? 1 : 2}
              placeholder="Écris ici..."
              className={'w-full resize-none rounded outline-hidden focus:bg-amber-50 ' + STYLES[block.type]}
            />
          </div>
        ))}
      </div>

      <div className="mx-auto mt-3 max-w-xl space-y-2 rounded-xl bg-gray-900 p-4 text-sm text-white">
        <p>Horloge simulée : <strong>{formatClock(state.now)}</strong></p>
        <p>
          Prochaine sauvegarde dans : <strong>{secondsLeft} s</strong>{' '}
          ({state.agentBug ? "version de l'agent : compte depuis la dernière touche" : 'correctif : toutes les 30 s depuis le départ'})
        </p>
        <p>
          Dernière sauvegarde :{' '}
          {state.saves.length ? formatClock(state.saves[0].at) + ' (' + state.saves[0].words + ' mots)' : "rien n'a encore été enregistré"}
        </p>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={state.typing} onChange={(e) => dispatch({ type: 'typing', value: e.target.checked })} />
          Le capitaine écrit sans pause (un mot par seconde)
        </label>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={state.agentBug} onChange={(e) => dispatch({ type: 'agentBug', value: e.target.checked })} />
          Bug de l&apos;agent : setTimeout avec [draft] dans les dépendances
        </label>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={fast} onChange={setFast} />
          Horloge rapide (5 fois plus vite)
        </label>
      </div>
    </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. Pourquoi newBlock, dans l'éditeur de chronique, donne-t-il au bloc un id issu de crypto.randomUUID() et non de Date.now().toString() ?

  2. 2. Pourquoi, dans le type SavedDraft, le champ savedAt a-t-il le type string et non Date ?

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

Tâches pratiques dans le jeu

  • Clique dans l'ordre

    Clique sur les éléments pour construire le comptage des mots d'un bloc, où un bloc vide donne 0 mot :

  • Tri horizontal

    Ordonne sur une seule ligne la modification du texte d'un bloc par une fonction de mise à jour :

  • Tri vertical

    Ordonne le travail sur l'éditeur de chronique en mode plan :

  • Éditeur de code

    Composant d'éditeur de texte enrichi

  • Clique dans l'ordre

    Clique sur les éléments pour construire le retour d'un tableau avec un nouveau bloc inséré après le bloc d'indice index :

  • Tri horizontal

    Ordonne sur une seule ligne le démarrage de l'horloge qui appelle toutes les 30 secondes la sauvegarde du brouillon courant :

  • Éditeur de code

    Interface du système de brouillons

  • Tri vertical

    La version de l'agent a un setTimeout dans un useEffect avec la dépendance [draft]. Ordonne ce qui se passe quand le capitaine écrit sans pause :

  1. QuestionIdentifiants des blocs
  2. QuestionDate de sauvegarde du brouillon en chaîne
  3. Clique dans l'ordreDes mots sans morceaux vides
  4. Remets dans l'ordreModifier le texte d'un seul bloc
  5. Remets dans l'ordreL'éditeur en mode plan
  6. Exercice de codePratique : Éditeur d'articles
  7. QuestionTemps de lecture d'une chronique vide
  8. QuestionUn nouveau paquet dans le diff
  9. Clique dans l'ordreInsertion après un bloc donné
  10. Remets dans l'ordreHorloge de la sauvegarde automatique
  11. Exercice de codePratique : Gestion des brouillons
  12. QuestionPlace de la directive use client
  13. Remets dans l'ordrePourquoi la sauvegarde de l'agent reste muette
  14. QuestionLa sauvegarde qui a passé le test

Articles utiles