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

La rédaction sous pavillon : publications, permissions et recommandations

9 min de lecture
Dans cette leçon9

Un seul auteur, c'est un seul bateau mais la chronique grandit en flotte. Le capitaine veut des publications, c'est-à-dire une page commune à plusieurs auteurs avec leur propre équipage : le propriétaire la dirige, l'éditeur publie les textes et l'auteur les soumet. Une question se pose, que le code laisse facilement passer : qui peut vraiment appuyer sur "Publier" ? Dans cette leçon, tu construis la page de publication à partir d'un croquis, tu surveilles les permissions sur le serveur et tu ajoutes des recommandations qu'on peut expliquer à quelqu'un.

Ce que tu vas apprendre

  • donner à Claude ton propre croquis comme partie de la demande ;
  • lire des onglets décrits par un type au lieu de as any, et une liste avec des clés stables ;
  • vérifier la permission sur le serveur et le prouver avec la commande curl ;
  • commander un score de recommandation qu'on peut décrire en une phrase.

Un croquis comme demande

Une mise en page se décrit mal avec des mots, donc tu la montres par un dessin, comme dans la leçon 3_2. Dessine sur une feuille ton propre croquis : le nom de la publication et le nombre d'abonnés en haut, dessous trois onglets, plus bas une liste de titres. Dessine ton idée, ne recopie pas et ne colle pas la capture d'une plateforme étrangère. Enregistre la photo de la feuille dans le projet sous croquis/publication.jpg. Le croquis dit à quoi la page ressemble, et le texte de la demande dit comment elle fonctionne et qui peut quoi.

Demande pour Claude Code :

/plan D'abord, décris en quelques phrases le croquis
croquis/publication.jpg. Ensuite, planifie la page
/publications/[slug] disposée comme sur le croquis : nom et nombre
d'abonnés, onglets Récents, Meilleurs et À propos, liste d'articles.
Types dans types/publication.ts, données d'exemple dans
lib/publications.ts. Rôles : owner, editor, writer. Seuls owner et
editor publient : la route POST /api/articles/[id]/publish vérifie le
rôle sur le serveur et renvoie 403 aux autres. Pas de connexion : qui
tu es, c'est le cookie demo-user dans lib/session.ts. Pas de as any.
Ce sera fini quand curl en tant que writer reçoit 403, en tant
qu'editor 200, et que npm run lint, npx tsc --noEmit et npm run build
passent.

Lis la description du croquis au début du plan. Si Claude s'est trompé sur l'endroit où se trouvent les onglets, corrige le plan avant que le code n'existe.

Ce que Claude a écrit : les rôles et une seule permission

Ouvre types/publication.ts dans Cursor. Un rôle est l'un de trois noms, et un membre de la publication relie une personne à un rôle :

// types/publication.ts
export type Role = "owner" | "editor" | "writer";

export interface PublicationMember {
  userId: string;
  name: string;
  role: Role;
}

Publication, dans le même fichier, a encore un slug, un nom, une description, le nombre d'abonnés et la liste members. La permission découle du rôle, donc lib/publications.ts contient une seule fonction au lieu de plusieurs champs vrai-faux éparpillés dans les données :

// lib/publications.ts
// Le propriétaire et l'éditeur publient. L'auteur ne fait que soumettre un texte.
export function canPublish(role: Role | undefined): boolean {
  return role === "owner" || role === "editor";
}

undefined désigne quelqu'un hors de l'équipage de la publication : la fonction renvoie false pour lui. Une seule fonction, c'est un seul endroit à changer le jour où le capitaine décide que les auteurs peuvent aussi publier.

Ce que Claude a écrit : des onglets avec un type

Ouvre components/PublicationTabs.tsx. La liste des onglets se termine par as const :

// components/PublicationTabs.tsx
const TABS = [
  { key: "latest", label: "Récents" },
  { key: "top", label: "Meilleurs" },
  { key: "about", label: "À propos" },
] as const;

type TabKey = (typeof TABS)[number]["key"];

as const dit à TypeScript que key vaut exactement "latest", "top" ou "about", et non une chaîne quelconque. TabKey extrait ces trois noms du tableau, donc un nouvel onglet ajouté à TABS entre aussitôt dans le type. Le clic est un simple onClick={() => setTab(t.key)}, sans conversion.

Le chemin typique de l'agent est différent. Un type d'onglets écrit à part et un tableau sans as const ont donné chez nous une erreur tsc : Argument of type 'string' is not assignable to parameter of type 'SetStateAction<TabKey>'. La "correction" la plus rapide est setTab(t.key as any), qui fait taire le compilateur. npm run lint ne l'a pas laissée passer : Unexpected any. Specify a different type. Quand Claude propose as any, demande un type qui convient, comme dans la leçon 1_4.

Ce que Claude a écrit : une clé tirée des données

La liste d'articles trie une copie des données selon l'onglet, et chaque élément reçoit une clé tirée de l'identifiant de l'article :

// components/PublicationTabs.tsx
{sorted.map((article) => (
  <li key={article.id}>

sorted est [...articles].sort(...) : par date pour les Récents, par applaudissements pour les Meilleurs. La documentation de React met en garde contre l'indice comme clé précisément quand l'ordre change : avec key={i}, après le changement d'onglet, React associe l'état et les éléments par position, et non par article. Elle met aussi en garde contre key={Math.random()}, qui recrée toute la liste à chaque rendu.

La serrure sur le serveur

Le bouton "Publier" n'apparaît que pour les membres avec canPublish. C'est un confort, pas une protection : on peut envoyer la requête sans la page. L'erreur typique de l'agent est de vérifier le rôle seulement dans le composant et de considérer l'affaire close. C'est pourquoi la route décide :

// app/api/articles/[id]/publish/route.ts
export async function POST(_request: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const article = getArticle(id);
  if (!article) {
    return Response.json({ error: "Cet article n'existe pas" }, { status: 404 });
  }
  const role = roleIn(article.publication, await getCurrentUserId());
  if (!canPublish(role)) {
    return Response.json({ error: "Seuls le propriétaire et les éditeurs peuvent publier" }, { status: 403 });
  }
  publishArticle(id);
  return Response.json({ id, status: "published" });
}

roleIn cherche le rôle de la personne dans la publication de l'article, et getCurrentUserId, de lib/session.ts, lit le cookie demo-user. C'est une fausse connexion, utile seulement pour apprendre : dans une vraie application, l'identifiant vient de la session de la leçon 8_5. Teste la serrure depuis le terminal, en auteur puis en éditeur :

curl -s -X POST -b "demo-user=u-jack" localhost:3000/api/articles/a4/publish -w ' %{http_code}\n'
curl -s -X POST -b "demo-user=u-bill" localhost:3000/api/articles/a4/publish -w ' %{http_code}\n'

Chez nous, l'auteur Calico Jack a reçu {"error":"Seuls le propriétaire et les éditeurs peuvent publier"} 403, et l'éditeur Billy Bones {"id":"a4","status":"published"} 200. Dans le navigateur, après avoir posé le cookie de l'éditeur dans la console des outils de développement, un clic sur "Publier" a fait passer le texte dans la liste des Récents.

Des recommandations qu'on peut expliquer

La page d'accueil doit montrer au lecteur des textes pour lui. La demande "ajoute un algorithme de recommandation" peut finir en commentaire vide du genre "algorithme ici", ou en formule avec des poids que personne ne sait justifier. Il vaut mieux commander une règle que tu vérifies toi-même sur tes doigts : "Dans lib/recommend.ts, ajoute un score : 3 par sujet suivi, 2 pour un auteur suivi, 1 par tranche pleine de 100 applaudissements, mais au plus 3 pour les applaudissements. Écris la règle dans un commentaire au-dessus de la fonction et ajoute un test avec les points d'articles d'exemple."

// lib/recommend.ts
export function score(article: Article, reader: Reader): number {
  const topics = article.topics.filter((t) => reader.followedTopics.includes(t)).length;
  const author = reader.followedAuthors.includes(article.authorId) ? 1 : 0;
  const claps = Math.min(3, Math.floor(article.claps / 100));
  return 3 * topics + 2 * author + claps;
}

Reader est la paire de listes de sujets et d'auteurs que le lecteur suit. recommend trie une copie des articles selon les points, et à égalité le plus récent gagne. La limite sur les applaudissements a une raison : avec un point par tranche de 10 applaudissements et sans plafond, "La carte au trésor", avec ses 340 applaudissements, recevrait 34 points et écraserait n'importe quel sujet suivi. Chez nous, le test a calculé pour un lecteur qui suit la navigation et l'autrice Mary les points { a1: 4, a2: 3, a3: 5, a4: 3 }.

La revue du capitaine

  1. La serrure. La permission est vérifiée par la route, et pas seulement par un bouton caché. Les commandes curl en tant qu'auteur et en tant qu'éditeur sont ta preuve.
  2. Des types au lieu de conversions. Cherche as any dans le projet (Cmd+Shift+F) : zéro résultat, et npm run lint se termine sans erreur.
  3. Les clés. Chaque key= dans les listes est un identifiant issu des données, pas un indice et pas Math.random().
  4. Le score. Le commentaire au-dessus de score décrit la règle en une phrase, et le test vérifie des nombres précis.
  5. Mémoire du serveur. publishArticle ajoute l'identifiant à un ensemble sur globalThis, comme les applaudissements de la leçon 11_2. La première version modifiait le champ status dans les données du module : chez nous, la route a répondu 200, et la page, après actualisation, montrait toujours le texte comme soumis, car la route avait modifié sa propre copie des données.

Étape suivante

Demande un commit "Publications, permissions et recommandations". Puis la page d'accueil. Le changement touchera au moins trois fichiers, donc recommence par un plan :

/plan Sur la page d'accueil, ajoute les onglets Pour toi et Suivis.
Pour toi utilise recommend de @lib/recommend.ts, Suivis montre les
textes des auteurs suivis, du plus récent au plus ancien. À côté de
la liste, un panneau avec les sujets. Type des onglets comme dans
PublicationTabs, sans as any.

Lis le plan comme aujourd'hui : les onglets ont-ils un type, les listes ont-elles des clés tirées des données, et le tri se fait-il sur une copie ? Dans l'éditeur ci-dessous t'attend la page de publication en miniature : change de rôle, essaie de publier un texte avec le bug de l'agent "serrure seulement dans le bouton" activé, et vérifie les points de recommandation.

Retiens ceci : la flotte navigue en sécurité quand seuls le capitaine et les officiers ont les clés de la timonerie, et que la serrure est posée sur la porte de la timonerie, pas sur la carte que chacun peut redessiner.

Code de cette leçon : App.jsx
// Publication en miniature : rôles, onglets, serrure sur un faux serveur et score de recommandation
import { useState } from 'react';

const MEMBERS = [
  { userId: 'u-anne', name: 'Anne Bonny', role: 'owner' },
  { userId: 'u-bill', name: 'Billy Bones', role: 'editor' },
  { userId: 'u-jack', name: 'Calico Jack', role: 'writer' },
];
const ROLE_LABELS = { owner: 'propriétaire', editor: 'éditeur', writer: 'auteur' };

const TABS = [
  { key: 'latest', label: 'Récents' },
  { key: 'top', label: 'Meilleurs' },
  { key: 'about', label: 'À propos' },
];

const ARTICLES = [
  { id: 'a1', publication: 'chroniques', title: "Comment survivre à une tempête en Atlantique", authorId: 'u-anne', topics: ['navigation', 'météo'], claps: 120, publishedAt: '2026-11-10' },
  { id: 'a2', publication: 'chroniques', title: "La carte au trésor introuvable", authorId: 'u-jack', topics: ['trésors'], claps: 340, publishedAt: '2026-11-12' },
  { id: 'a3', publication: 'cambuse', title: "Le cuisinier de bord conseille : du biscuit pour six semaines", authorId: 'u-mary', topics: ['cuisine', 'navigation'], claps: 45, publishedAt: '2026-11-14' },
  { id: 'a4', publication: 'chroniques', title: "Le quart de nuit sans café", authorId: 'u-jack', topics: ['navigation'], claps: 0, publishedAt: '2026-11-15' },
];
const AUTHORS = { 'u-anne': 'Anne Bonny', 'u-jack': 'Calico Jack', 'u-mary': 'Mary Read' };
const TOPICS = ['navigation', 'météo', 'trésors', 'cuisine'];

// Le propriétaire et l'éditeur publient. L'auteur ne fait que soumettre un texte.
function canPublish(role) {
  return role === 'owner' || role === 'editor';
}

function roleOf(userId) {
  const member = MEMBERS.find((m) => m.userId === userId);
  return member ? member.role : undefined;
}

// Faux serveur : la route POST /api/articles/a4/publish
function publishOnServer(userId, lockOnlyInButton) {
  if (!lockOnlyInButton && !canPublish(roleOf(userId))) return 403;
  return 200;
}

// 3 par sujet suivi, 2 pour un auteur suivi, 1 par tranche pleine de 100 applaudissements (au plus 3)
function score(article, reader, noCap) {
  const topics = article.topics.filter((t) => reader.topics.includes(t)).length;
  const author = reader.authors.includes(article.authorId) ? 1 : 0;
  const clapPoints = noCap ? Math.floor(article.claps / 10) : Math.min(3, Math.floor(article.claps / 100));
  return 3 * topics + 2 * author + clapPoints;
}

export default function App() {
  const [userId, setUserId] = useState('u-jack');
  const [tab, setTab] = useState('latest');
  const [publishedIds, setPublishedIds] = useState(['a1', 'a2', 'a3']);
  const [lockOnlyInButton, setLockOnlyInButton] = useState(false);
  const [log, setLog] = useState('');
  const [reader, setReader] = useState({ topics: ['navigation'], authors: ['u-mary'] });
  const [noCap, setNoCap] = useState(false);

  const role = roleOf(userId);
  const published = ARTICLES.filter((a) => publishedIds.includes(a.id));
  const submitted = ARTICLES.filter((a) => a.id === 'a4' && !publishedIds.includes(a.id));
  const mine = published.filter((a) => a.publication === 'chroniques');
  const sorted =
    tab === 'top'
      ? [...mine].sort((a, b) => b.claps - a.claps)
      : [...mine].sort((a, b) => b.publishedAt.localeCompare(a.publishedAt));
  const recommended = [...published]
    .map((a) => ({ article: a, points: score(a, reader, noCap) }))
    .sort((a, b) => b.points - a.points || b.article.publishedAt.localeCompare(a.article.publishedAt));

  function publish(source) {
    const status = publishOnServer(userId, lockOnlyInButton);
    setLog(source + ' : le serveur a répondu ' + status);
    if (status === 200) setPublishedIds((ids) => (ids.includes('a4') ? ids : [...ids, 'a4']));
  }

  function toggle(list, value) {
    return list.includes(value) ? list.filter((v) => v !== value) : [...list, value];
  }

  return (
    <div className="min-h-screen bg-gray-50 p-4 text-gray-900">
      <div className="mx-auto max-w-xl space-y-4 rounded-xl bg-white p-4 shadow-sm">
        <label className="block text-sm">
          Connecté (faux cookie demo-user) :{' '}
          <select value={userId} onChange={(e) => setUserId(e.target.value)} className="rounded border border-gray-300">
            {MEMBERS.map((m) => (
              <option key={m.userId} value={m.userId}>{m.name} ({ROLE_LABELS[m.role]})</option>
            ))}
            <option value="u-guest">Invité hors de l&apos;équipage</option>
          </select>
        </label>
        <header>
          <h1 className="text-2xl font-bold">Chroniques du Cap</h1>
          <p className="text-gray-600">{(12480).toLocaleString('fr-FR')} abonnés</p>
        </header>
        <div role="tablist" className="flex gap-4 border-b border-gray-200">
          {TABS.map((t) => (
            <button
              key={t.key}
              type="button"
              role="tab"
              aria-selected={tab === t.key}
              onClick={() => setTab(t.key)}
              className={tab === t.key ? 'border-b-2 border-gray-900 pb-2 font-semibold' : 'pb-2 text-gray-500'}
            >
              {t.label}
            </button>
          ))}
        </div>
        {tab === 'about' ? (
          <ul>
            {MEMBERS.map((m) => (
              <li key={m.userId}>{m.name}: {ROLE_LABELS[m.role]}</li>
            ))}
          </ul>
        ) : (
          <ul className="space-y-2">
            {sorted.map((article) => (
              <li key={article.id}>
                <p className="font-semibold">{article.title}</p>
                <p className="text-sm text-gray-500">{article.claps} applaudissements · {article.publishedAt}</p>
              </li>
            ))}
          </ul>
        )}
        {submitted.length > 0 && canPublish(role) && (
          <div className="rounded bg-amber-50 p-2 text-sm">
            Soumis : {submitted[0].title}{' '}
            <button type="button" onClick={() => publish('Bouton')} className="rounded bg-gray-900 px-2 py-1 text-white">
              Publier
            </button>
          </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">
        <button type="button" onClick={() => publish('Requête sans passer par le bouton')} className="rounded bg-gray-700 px-3 py-1">
          Envoyer POST /api/articles/a4/publish (comme curl)
        </button>
        {log && <p className="text-amber-300">{log}</p>}
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={lockOnlyInButton} onChange={(e) => setLockOnlyInButton(e.target.checked)} />
          Bug de l&apos;agent : serrure seulement dans le bouton
        </label>
      </div>

      <div className="mx-auto mt-3 max-w-xl space-y-2 rounded-xl bg-white p-4 text-sm shadow-sm">
        <p className="font-semibold">Pour toi : points de recommandation</p>
        <div className="flex flex-wrap gap-3">
          {TOPICS.map((t) => (
            <label key={t} className="flex items-center gap-1">
              <input type="checkbox" checked={reader.topics.includes(t)} onChange={() => setReader((r) => ({ ...r, topics: toggle(r.topics, t) }))} />
              {t}
            </label>
          ))}
          <label className="flex items-center gap-1">
            <input type="checkbox" checked={reader.authors.includes('u-mary')} onChange={() => setReader((r) => ({ ...r, authors: toggle(r.authors, 'u-mary') }))} />
            je suis Mary Read
          </label>
        </div>
        <ol className="list-decimal pl-5">
          {recommended.map(({ article, points }) => (
            <li key={article.id}>
              {article.title} ({AUTHORS[article.authorId]}): <strong>{points} pts</strong>
            </li>
          ))}
        </ol>
        <label className="flex items-center gap-2">
          <input type="checkbox" checked={noCap} onChange={(e) => setNoCap(e.target.checked)} />
          Sans plafond : 1 point par tranche de 10 applaudissements
        </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. Que donnes-tu à Claude comme croquis de la page de publication ?

  2. 2. Pourquoi la demande dit-elle à Claude de décrire d'abord le croquis en quelques phrases, et de planifier seulement ensuite ?

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

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne le chemin du texte d'un auteur jusqu'à l'onglet Récents :

  • Éditeur de code

    Affichage de la publication

  • Clique dans l'ordre

    Clique sur les éléments pour construire les points d'applaudissements avec un plafond de 3 :

  • Éditeur de code

    Interface du fil

  • Tri vertical

    Ordonne les lignes de la définition des onglets dont TypeScript tire le type TabKey :

  • Tri horizontal

    Ordonne sur une seule ligne la gestion du clic sur un onglet avec le type TabKey :

  • Tri vertical

    Ordonne les rôles d'une publication des permissions les plus larges aux plus étroites :

  • Tri horizontal

    Ordonne sur une seule ligne la lecture du rôle d'une personne dans la route de publication :

  • Clique dans l'ordre

    Clique sur les éléments pour construire la liste des Meilleurs sans modifier le tableau venu des props :

  • Tri vertical

    Ordonne les lignes de la route de publication, de la lecture des paramètres à l'écriture :

  • Tri horizontal

    Ordonne sur une seule ligne l'en-tête d'une route POST avec les paramètres sous forme de promesse :

  1. QuestionCroquis de la page de publication
  2. QuestionDescription du croquis avant le plan
  3. Remets dans l'ordreLe chemin d'un texte jusqu'à la publication
  4. Exercice de codePratique : page de publication
  5. QuestionUn score qu'on peut expliquer
  6. QuestionPoints d'un seul article
  7. Clique dans l'ordrePoints d'applaudissements avec plafond
  8. Exercice de codePratique : fil principal
  9. QuestionQui publie dans une publication
  10. QuestionSerrure seulement dans le bouton
  11. Remets dans l'ordreOnglets avec un type
  12. Remets dans l'ordreClic sur un onglet sans conversion
  13. QuestionErreur de type d'onglet et as any
  14. QuestionClé d'un élément de liste
  15. Remets dans l'ordreRôles du plus large au plus étroit
  16. Remets dans l'ordreRôle issu du cookie sur le serveur
  17. Clique dans l'ordreMeilleurs depuis une copie de la liste
  18. QuestionPlafond des points d'applaudissements
  19. Remets dans l'ordreOrdre dans la route de publication
  20. Remets dans l'ordreEn-tête de la route POST
  21. QuestionRoute en 200, page inchangée

Articles utiles