Cours Vibe coding avec Claude Code · Module 13: Clone de Twitch

Un pipeline sous pavillon : la CI écrite par Claude Code

10 min de lecture
Dans cette leçon7

Le coffre est emballé mais il reste un trou dans le port. Toi, avant chaque commit, tu lances le lint, les tests et le build, parce que c'est devenu une habitude. Le bosco, lui, est pressé : il pousse sur main une modification qu'il n'a pas construite, et au matin personne ne peut appareiller. Il te faut un gardien de phare qui contrôle chaque navire avant son entrée au port, quel que soit celui qui le pilote.

Ce gardien de phare, c'est la CI (continuous integration, c'est-à-dire intégration continue) : à chaque modification, un serveur lance tout seul les mêmes vérifications que celles que tu fais en local. Sur GitHub, c'est GitHub Actions qui s'en charge. Tu écris les instructions dans un fichier YAML du dossier .github/workflows/, et un tel fichier s'appelle un workflow. Le résultat apparaît à côté du commit et de la pull request, que tu connais depuis la leçon 1_5 comme une demande de fusion d'une branche, avec de la place pour la revue de code : une coche verte ou une croix rouge.

Ce que tu vas apprendre

  • décrire à Claude Code le but de la vérification au lieu de dicter le YAML, et lui faire vérifier les versions des actions au lieu de deviner ;
  • lire un workflow clé par clé : on, permissions, jobs, steps ;
  • reconnaître un test vert qui ne teste rien ;
  • lancer Claude Code sans conversation, avec claude -p, des permissions étroites et un résultat en JSON ;
  • garder le jeton de déploiement dans les secrets du dépôt, et non dans la demande.

Demande pour Claude Code

La demande dit ce qui doit se passer et quand, pas à quoi doit ressembler le fichier. Deux phrases y comptent le plus : celle sur les versions des actions et celle sur le script manquant.

Demande pour Claude Code :

Ajoute un workflow GitHub Actions dans .github/workflows/ci.yml : à
chaque push et pull request sur main, installe les dépendances (npm ci),
lance le lint, les tests en un seul passage et le build. Vérifie avec gh
les dernières versions de actions/checkout et actions/setup-node et
utilise leurs versions majeures, et Node.js dans sa version LTS
actuelle. Jeton du workflow en lecture seule. S'il manque un script
dans package.json, dis-le-moi au lieu de l'inventer. Laisse le
déploiement de côté pour l'instant.
Ce sera fini quand : ci.yml se parse, et npm ci, npm run lint,
npm run test -- --run et npm run build passent en local.

L'agent ne connaît pas les versions des actions. Il se souvient de celles des textes sur lesquels il a appris, et les exemples du web ont souvent plusieurs versions de retard. C'est pourquoi tu lui demandes de vérifier, et il te demandera l'accord pour une commande gh de la leçon 1_5 :

gh api repos/actions/checkout/releases/latest --jq .tag_name

gh api interroge l'API de GitHub sur la dernière version publiée du dépôt de l'action, et --jq .tag_name extrait de la réponse le seul nom de la version. Pareil pour actions/setup-node. Chez nous, cela a donné v7.0.1 et v7.1.0 : le workflow utilise donc @v7, et le Node.js LTS actuel est le 26 (état en novembre 2026).

Ce que Claude a écrit : le workflow clé par clé

Ouvre .github/workflows/ci.yml dans Cursor. En haut se trouvent le nom et le moment où le workflow démarre :

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

on dit quels évènements déclenchent le workflow : ici un push sur main et une pull request dirigée vers main. Un push sur une autre branche ne déclenche rien à lui seul ; la vérification démarrera quand tu ouvriras une pull request depuis cette branche, et se répétera à chaque nouveau commit dans cette pull request. Ensuite, les permissions :

permissions:
  contents: read

permissions fixe ce que peut faire le jeton que GitHub donne au workflow pendant l'exécution (GITHUB_TOKEN). La documentation de GitHub conseille de garder le minimum, et dès que tu cites une seule permission, toutes celles qui ne sont pas citées reçoivent none. Notre workflow ne fait que lire le code : il n'écrira donc rien dans le dépôt, même si quelqu'un lui glissait une étape malveillante. Passons au vrai travail :

jobs:
  check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 26

jobs est la liste des tâches ; notre unique tâche s'appelle check, et runs-on choisit la machine sur laquelle GitHub la lancera. steps sont les étapes de cette tâche, exécutées l'une après l'autre. uses lance une action toute prête : checkout récupère le code du dépôt sur la machine, et setup-node installe Node.js dans la version de node-version. À la fin, quatre commandes :

      - run: npm ci
      - run: npm run lint
      - run: npm run test -- --run
      - run: npm run build

run exécute une commande dans le shell de la machine. Quand une étape échoue, la tâche se termine en erreur, et les étapes suivantes ne démarrent pas. --run demande à Vitest de faire un seul passage puis de s'arrêter. GitHub définit sur ses machines la variable CI=true, et selon sa documentation, Vitest passe alors tout seul en un seul passage, mais l'écriture explicite fonctionne de la même façon chez toi et figure déjà dans CLAUDE.md depuis la leçon 12_1. Chez nous, le fichier s'est parsé, et les quatre commandes ont passé en local avec CI=true.

Le mensonge vert

Notre clone a Vitest depuis la leçon 12_1, mais beaucoup de projets n'ont aucun test. L'étape des tests s'arrête alors dès le départ, comme chez nous dans un projet sans script test :

npm error Missing script: "test"

L'erreur typique d'un agent est une "réparation" dans package.json : un script "test": "exit 0" ou "test": "echo ok". Le workflow s'allume alors en vert, sans rien vérifier. C'est pourquoi la demande dit de signaler le script manquant. Dans le diff, tu reconnais l'astuce tout de suite : package.json modifié dans la même étape que le workflow, alors que personne n'a demandé de nouveaux scripts.

La vérification avant le push : claude -p

Le workflow ne démarrera que sur GitHub. Avant de pousser le fichier, tu peux demander à Claude une comparaison rapide du workflow et des scripts, et cela sans ouvrir de conversation. Le mode non interactif, claude -p, reçoit une seule demande, affiche le résultat et s'arrête. La documentation l'appelle l'Agent SDK en ligne de commande : le même agent et les mêmes outils, simplement sans fenêtre. Tape dans un onglet de terminal séparé, dans le dossier du projet :

claude -p "Compare les étapes run de .github/workflows/ci.yml avec les scripts de package.json et liste les scripts manquants." --allowedTools "Read" --permission-mode dontAsk --max-turns 3 --output-format json

Chaque option réduit la marge de manœuvre :

  • --allowedTools "Read" liste les outils que Claude utilise sans demander ;
  • --permission-mode dontAsk refuse tout appel qui, dans une session normale, attendrait ton accord ; la documentation recommande ce mode pour les exécutions fermées en CI, où personne ne répondra à une question ;
  • --max-turns 3 limite le nombre de tours de l'agent, alors que par défaut il n'y a aucune limite ;
  • --output-format json renvoie le résultat en JSON au lieu du simple texte.

Dans le JSON, le texte de la réponse se trouve dans le champ result. À côté, d'autres champs méritent l'attention : num_turns (le nombre de tours), total_cost_usd (une estimation du coût selon les tarifs de l'API, pas une facture) et permission_denials, c'est-à-dire la liste des appels que le mode dontAsk a refusés. Chez nous, l'exécution a duré environ 18 secondes et utilisé trois tours. Dans result, Claude a écrit un tableau : chaque étape run a son script, et npm ci n'en a besoin d'aucun. Il a ajouté une remarque : la CI ne lance pas le npx tsc --noEmit de CLAUDE.md ; next build vérifie de toute façon les types, ce qui se voit dans son journal sous la forme Running TypeScript. Le champ permission_denials était vide, mais avec une autre demande, il a reçu une commande node -e que Claude avait essayé de lancer avant de prendre Read. L'estimation du coût était d'environ un demi-dollar : même un petit automate n'est donc pas gratuit. Dans un script, c'est le programme jq qui extrait la réponse seule, par exemple jq -r '.result', comme le montre la documentation.

La revue du capitaine

  1. Versions. uses: pointe vers les mêmes versions majeures que celles affichées par gh api, et node-version est le LTS actuel. De mémoire, l'agent écrit des versions vieilles de plusieurs années.
  2. Permissions. Il y a permissions avec contents: read.
  3. Scripts. Chaque étape run a son script dans package.json, et l'étape des tests se termine toute seule grâce à --run.
  4. Secrets. Le fichier ne contient aucun jeton ni mot de passe.

Le vrai test a lieu sur GitHub. Demande à Claude : "Crée une branche ci, fais un commit, pousse-la et ouvre avec gh une pull request vers main". Sur la page de la pull request apparaîtra la vérification CI. Clique dessus, et tu verras le journal de chaque étape. Une croix rouge n'est pas une honte, c'est un phare qui fonctionne : lis quelle étape a échoué et donne ce passage du journal à Claude.

Étape suivante

Quand la CI s'allume en vert, fusionne la pull request. L'étape suivante est le déploiement depuis le workflow, et là le capitaine pose une règle ferme : le jeton Vercel ne va ni dans la demande, ni dans un fichier, ni dans la conversation. Ce que tu écris dans une demande devient une partie de la conversation, et de là peut finir dans le code, un commit ou un journal, comme le contenu du fichier .env dans la leçon 8_4. Tu le crées toi-même dans le tableau de bord de Vercel et tu l'ajoutes toi-même sur GitHub : dans le dépôt, Settings, puis Secrets and variables, Actions et New repository secret, avec le nom VERCEL_TOKEN. Le guide de Vercel sur GitHub Actions exige encore deux secrets, VERCEL_ORG_ID et VERCEL_PROJECT_ID, tirés du fichier .vercel/project.json que crée vercel link. Ensuite, tu demandes :

Demande pour Claude Code :

Ajoute un déploiement de prévisualisation sur Vercel selon le guide
de Vercel sur GitHub Actions. Lis le jeton dans le secret VERCEL_TOKEN,
les identifiants dans VERCEL_ORG_ID et VERCEL_PROJECT_ID. Tu n'as pas
besoin des valeurs des secrets, ne les demande pas.

Dans le fichier de Claude, cherche des références aux secrets à la place des valeurs, par exemple dans une ligne comme celle-ci, tirée du guide de Vercel :

run: vercel pull --yes --environment=preview --token=${{ secrets.VERCEL_TOKEN }}

GitHub ne remplace l'écriture ${{ secrets.VERCEL_TOKEN }} par la valeur que sur sa propre machine, pendant l'exécution. La documentation de GitHub ajoute que les secrets ne sont pas transmis aux workflows lancés depuis des forks, c'est-à-dire des copies du dépôt chez d'autres personnes. Si, dans la leçon 10_5, tu as importé le dépôt dans le tableau de bord de Vercel, Vercel déploie déjà tout seul après chaque push : choisis une voie, pas les deux. Dans l'éditeur ci-dessous t'attend un lecteur de workflow : clique sur les clés et lance une exécution simulée avec un script manquant ou avec le mensonge vert de l'agent.

Retiens ceci : le phare ne gouverne pas le navire, mais chaque nuit il vérifie que celui-ci arrive au port sans encombre.

Code de cette leçon : App.tsx
// Lecteur de workflow CI : ce que signifient les clés de ci.yml et ce que montrera l'exécution sur GitHub
import { useState } from 'react';

type KeyName = 'on' | 'permissions' | 'jobs' | 'steps';
type TestScript = 'vitest' | 'none' | 'fake';
type StepStatus = 'ok' | 'fail' | 'skipped';

interface StepResult {
  name: string;
  status: StepStatus;
  log: string;
}

const WORKFLOW: { text: string; key?: KeyName }[] = [
  { text: 'name: CI' },
  { text: 'on:', key: 'on' },
  { text: '  push:', key: 'on' },
  { text: '    branches: [main]', key: 'on' },
  { text: '  pull_request:', key: 'on' },
  { text: '    branches: [main]', key: 'on' },
  { text: 'permissions:', key: 'permissions' },
  { text: '  contents: read', key: 'permissions' },
  { text: 'jobs:', key: 'jobs' },
  { text: '  check:', key: 'jobs' },
  { text: '    runs-on: ubuntu-latest', key: 'jobs' },
  { text: '    steps:', key: 'steps' },
  { text: '      - uses: actions/checkout@v7', key: 'steps' },
  { text: '      - uses: actions/setup-node@v7', key: 'steps' },
  { text: '        with:', key: 'steps' },
  { text: '          node-version: 26', key: 'steps' },
  { text: '      - run: npm ci', key: 'steps' },
  { text: '      - run: npm run lint', key: 'steps' },
  { text: '      - run: npm run test -- --run', key: 'steps' },
  { text: '      - run: npm run build', key: 'steps' },
];

const EXPLAIN: Record<KeyName, string> = {
  on: 'on: quand le workflow démarre. Ici à chaque push sur main et à chaque pull request dirigée vers main.',
  permissions: "permissions: ce que peut faire le jeton de l'exécution. contents: read permet seulement de lire le code ; les autres permissions reçoivent none.",
  jobs: 'jobs: les tâches du workflow. Une seule tâche check, et runs-on choisit la machine sur laquelle GitHub la lancera.',
  steps: "steps: les étapes de la tâche, l'une après l'autre. uses lance une action toute prête, run exécute une commande dans le shell.",
};

export function simulateRun(testScript: TestScript, lintError: boolean): StepResult[] {
  const plan: { name: string; run: () => { ok: boolean; log: string } }[] = [
    { name: 'actions/checkout', run: () => ({ ok: true, log: 'Code récupéré sur la machine' }) },
    { name: 'actions/setup-node', run: () => ({ ok: true, log: 'Node.js 26 prêt' }) },
    { name: 'npm ci', run: () => ({ ok: true, log: 'Dépendances selon package-lock.json' }) },
    {
      name: 'npm run lint',
      run: () => (lintError ? { ok: false, log: 'eslint a signalé une erreur dans components/LiveChat.tsx' } : { ok: true, log: 'eslint sans erreur' }),
    },
    {
      name: 'npm run test -- --run',
      run: () => {
        if (testScript === 'none') return { ok: false, log: 'npm error Missing script: "test"' };
        if (testScript === 'fake') return { ok: true, log: "> exit 0 (aucun test n'a été lancé)" };
        return { ok: true, log: 'Tests réussis : un seul passage et fin' };
      },
    },
    { name: 'npm run build', run: () => ({ ok: true, log: 'Compiled successfully' }) },
  ];

  const results: StepResult[] = [];
  let failed = false;
  for (const step of plan) {
    if (failed) {
      results.push({ name: step.name, status: 'skipped', log: 'Ignorée, car une étape précédente a échoué' });
      continue;
    }
    const outcome = step.run();
    results.push({ name: step.name, status: outcome.ok ? 'ok' : 'fail', log: outcome.log });
    if (!outcome.ok) failed = true;
  }
  return results;
}

export function verdict(results: StepResult[], testScript: TestScript): string {
  if (results.some((r) => r.status === 'fail')) return "Croix rouge : lis le journal de l'étape qui a échoué";
  if (testScript === 'fake') return "Coche verte, mais les tests n'ont rien vérifié : le mensonge vert";
  return 'Coche verte : le lint, les tests et le build ont passé';
}

const STATUS_LABEL: Record<StepStatus, string> = { ok: 'OK', fail: 'Erreur', skipped: 'Ignorée' };
const STATUS_CLASS: Record<StepStatus, string> = { ok: 'text-emerald-400', fail: 'text-red-400', skipped: 'text-zinc-500' };

export default function App() {
  const [active, setActive] = useState<KeyName>('on');
  const [testScript, setTestScript] = useState<TestScript>('vitest');
  const [lintError, setLintError] = useState(false);
  const results = simulateRun(testScript, lintError);

  return (
    <div className="min-h-screen space-y-4 bg-zinc-950 p-4 text-zinc-100">
      <h1 className="text-xl font-bold">Lecteur de workflow : ci.yml</h1>
      <div className="grid gap-4 md:grid-cols-2">
        <pre className="overflow-x-auto rounded bg-zinc-900 p-2 font-mono text-xs leading-5">
          {WORKFLOW.map((line, i) => (
            <div key={i}>
              {line.key ? (
                <button
                  type="button"
                  onClick={() => setActive(line.key as KeyName)}
                  aria-pressed={active === line.key}
                  className={active === line.key ? 'w-full bg-purple-900 text-left whitespace-pre' : 'w-full text-left whitespace-pre'}
                >
                  {line.text}
                </button>
              ) : (
                <span className="whitespace-pre text-zinc-400">{line.text}</span>
              )}
            </div>
          ))}
        </pre>
        <section className="space-y-2 text-sm">
          <h2 className="font-semibold">Clé : {active}</h2>
          <p>{EXPLAIN[active]}</p>
          <p className="text-zinc-400">Clique sur une ligne du fichier pour voir de quoi sa clé est responsable.</p>
        </section>
      </div>

      <fieldset className="space-y-1 text-sm">
        <legend className="font-semibold">Le script test dans package.json</legend>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'vitest'} onChange={() => setTestScript('vitest')} />
          {'"test": "vitest" (le projet de la leçon)'}
        </label>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'none'} onChange={() => setTestScript('none')} />
          pas de script test
        </label>
        <label className="flex items-center gap-2">
          <input type="radio" name="test" checked={testScript === 'fake'} onChange={() => setTestScript('fake')} />
          {'Version de l’agent : "test": "exit 0"'}
        </label>
        <label className="flex items-center gap-2 pt-2">
          <input type="checkbox" checked={lintError} onChange={(e) => setLintError(e.target.checked)} />
          Le bosco a poussé du code avec une erreur de syntaxe
        </label>
      </fieldset>

      <ol className="space-y-1 text-sm">
        {results.map((r) => (
          <li key={r.name} className="rounded border border-zinc-800 p-2">
            <strong className={STATUS_CLASS[r.status]}>{STATUS_LABEL[r.status]}</strong> {r.name}
            <p className="font-mono text-xs text-zinc-400">{r.log}</p>
          </li>
        ))}
      </ol>
      <p role="status" className="font-semibold">{verdict(results, testScript)}</p>
    </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 fait le workflow CI écrit dans la leçon ?

  2. 2. Quels évènements déclenchent le workflow CI de la leçon (la section on:) ?

Tâches pratiques dans le jeu

  • Tri vertical

    Ordonne les étapes (steps) de la tâche check dans le workflow CI :

  • Tri horizontal

    Ordonne la référence au token Vercel depuis secrets (une ligne) : ${{ secrets.VERCEL_TOKEN }}

  1. QuestionQuiz : ce que fait le workflow CI
  2. QuestionQuiz : quand démarre le workflow CI
  3. Remets dans l'ordreTri : les étapes de la tâche CI
  4. Remets dans l'ordreTri : la référence à un secret

Articles utiles