Cours Vibe coding avec Claude Code · Module 15: Claude Code avancé

Claude Code sans conversation : mode -p, pipes et sessions

13 min de lecture
Dans cette leçon13

Tu as derrière toi treize clones et tu as sûrement remarqué qu'une partie de tes ordres se répète chaque jour avec les mêmes mots. Avant un commit, tu demandes une revue des changements ; après une pause, un résumé du diff ; et quand la CI échoue, tu colles le journal et tu demandes la cause. À chaque fois, tu ouvres une session, tu retapes la même demande et tu attends. Dans ce dernier module, tu emmènes Claude Code là où personne ne le surveille : dans les scripts, les boucles et la CI.

Ce que tu sais déjà

Dans la leçon 12_5, tu as lancé claude -p avec les drapeaux --allowedTools, --permission-mode dontAsk, --max-turns et --output-format json, et dans la leçon 12_7 tu as installé Claude dans GitHub Actions. De la leçon 4_10, tu connais claude -c, claude -r et les sessions nommées, et de la leçon 2_9 la commande /code-review et la lecture du diff dans Cursor. Dans la leçon 1_5, tu as découvert git add, et dans la leçon 5_10 tu as appris que Sonnet coûte moins cher pour la routine. Je ne reviens pas là-dessus : j'ajoute ce dont a besoin un ordre donné sans conversation.

Ce que tu vas apprendre

  • fournir des données à Claude par un pipe et enregistrer la réponse dans un fichier ;
  • choisir le bon diff et ne pas en envoyer un vide ;
  • imposer la forme de la réponse par une phrase ou par un schéma JSON ;
  • restreindre les outils, choisir le modèle et savoir comment l'exécution se connecte ;
  • revenir aux exécutions -p comme à des sessions ordinaires.

Trois signes du terminal : |, < et >

Un flux est un texte qu'un programme reçoit en entrée ou écrit en sortie. La barre verticale |, c'est-à-dire le pipe, relie la sortie d'une commande à l'entrée de la suivante, et claude -p lit cette entrée en même temps que la demande :

git diff --cached | claude -p "Résume ces changements en trois points."

Claude reçoit le diff tout prêt, donc il n'a rien à chercher dans le projet. Aucun fichier ne change, et la commande se termine avec la réponse. Les deux autres signes redirigent le flux : < verse un fichier en entrée, et > enregistre la sortie dans un fichier.

claude -p "Explique la cause de la première erreur de ce journal." < build.log > explication.md

Attention à un point : > vide le fichier cible avant même que la commande démarre, donc ne dirige jamais la sortie vers un fichier que Claude doit lire. L'entrée d'un pipe est limitée à 10 Mo (état en novembre 2026) ; pour un fichier plus gros, indique son chemin dans la demande.

Quel diff : trois lots de changements

Git garde les changements à trois endroits, et chaque commande montre un lot différent :

git diff               # changements pas encore ajoutés par git add
git diff --cached      # zone de préparation (staging area) : ce qui ira dans le commit
git diff main...HEAD   # commits de la branche depuis son départ de main

Les trois points demandent de compter à partir de la bifurcation, donc tu ne verras pas les commits des autres arrivés entre-temps sur main. Aucune de ces commandes n'enregistre quoi que ce soit. Le piège se cache dans le diff vide : après git add, un simple git diff n'affiche rien, Claude reçoit la demande seule et te parlera de rien avec le plus grand aplomb. Avant un commit, tu relis donc --cached, avant une pull request main...HEAD.

Demande pour Claude Code

Dans Treasure Map, tu as demandé à Claude deux changements dans lib/pinInput.ts : un pin peut avoir une image à partir d'une adresse complète, et il peut avoir dix tags. Tu as fait git add lib/pinInput.ts, et avant de signer le commit tu veux une liste de problèmes, pas un exposé.

Demande pour Claude Code (dans le terminal de Cursor) :

git diff --cached | claude -p "Relis ces changements avant le commit : bugs et sécurité.
Réponds uniquement par une liste, une ligne par problème :
fichier:ligne | problème | proposition.
Sans introduction et sans résumé. Si tu ne trouves rien, écris : Rien à signaler." \
  --model sonnet --tools ""

La forme de la réponse est dans la demande, et deux drapeaux transforment la revue en réflexe rapide. --model sonnet prend le modèle moins cher pour la routine, et --tools "" retire à Claude tous les outils : il ne voit que le diff et répond en un seul tour.

Ce que Claude a écrit

Rien n'est apparu sur le disque, une liste s'affiche dans le terminal. Voici l'abrégé de notre exécution :

lib/pinInput.ts:9 | z.url() accepte tous les schémas (javascript:, data:, http:) et tous les hôtes | restreindre à https: et aux hôtes de images.remotePatterns
lib/pinInput.ts:9 | startsWith("/pins/") laisse passer /pins/../../autre | rejeter les chemins avec ..
lib/pinInput.ts:9 | le message commun de l'union a remplacé les messages précis | des messages séparés par branche
lib/pinInput.ts:13 | la limite est 10, mais le message dit "5 tags au maximum." | unifier la limite et le message
lib/pinInput.ts:13 | limite doublée sans justification | confirmer le changement et ajouter un test

Chaque ligne a un fichier, un numéro de ligne et une proposition, donc on peut la vérifier, et un script pourrait même les compter. Claude n'a rien corrigé : une revue par pipe donne un avis, pas une modification.

La revue du capitaine

Ouvre dans Cursor le panneau Source Control, déplie Staged Changes et clique sur lib/pinInput.ts. Compare chaque entrée avec le diff :

  1. La ligne est-elle dans le diff ? Les lignes 9 et 13 y sont. Un numéro hors du diff signale une remarque sur du vieux code ou une invention, donc vérifie-le dans le fichier.
  2. Le reproche se confirme-t-il ? Le premier oui : z.url() de Zod a laissé passer chez nous javascript:alert(1). Le deuxième concerne une ligne dont le sens n'a pas changé ; c'est une tâche à part, pas ce commit. Le cinquième est une supposition sans preuve, donc tu l'écartes.
  3. Que le relecteur n'a-t-il pas vu ? Le test "rejette une image hors de /pins/" dans lib/pinInput.test.ts échoue après ce changement, ce que montrera npm run test -- --run. Sans outils, Claude n'a pas regardé les tests : une revue rapide par pipe ne remplace ni les tests ni /code-review.

L'erreur typique de l'agent est l'essai à la place de la liste, quand la demande ne donne pas la forme de la réponse : des paragraphes, des titres et des compliments que tu ne peux pas comparer avec le diff. Tu la reconnais à la première phrase, du genre "Voici mon analyse", et une seule ligne avec le modèle de réponse la guérit.

Écrire sans permission : ce que fait -p

Que se passe-t-il quand, en mode -p, tu demandes d'écrire un fichier sans ajouter aucun drapeau de permission ? La documentation dit que claude -p démarre aujourd'hui en mode Manual et refuse tout appel qui demande une approbation. Nous l'avons vérifié sur Treasure Map :

claude -p "Écris des tests Vitest pour @lib/plural.ts et enregistre-les dans lib/plural.test.ts." \
  --model sonnet --tools "Read,Write" --max-turns 3 --output-format json

Le fichier n'a pas été créé. Dans le JSON, le champ permission_denials a listé l'outil refusé Write avec tout le contenu des tests, et dans result Claude a écrit que les permissions avaient bloqué l'écriture. Le plus important : la commande s'est terminée avec le code 0, donc en succès. Un script qui ne regarde que le code de sortie croira que tout s'est bien passé, alors vérifie le fichier ou permission_denials. Tu approuves l'écriture avec un drapeau (--allowedTools "Write" ou --permission-mode acceptEdits), ou tu demandes seulement le contenu et tu le diriges avec > vers un fichier, ce que tu verras dans la leçon suivante.

Trois drapeaux d'outils

Ces trois drapeaux se ressemblent et font des choses différentes :

claude -p "..." --tools "Read"                         # jeu d'outils : seulement Read
claude -p "..." --allowedTools "Bash(npm run test *)"  # tests sans demander, le reste comme avant
claude -p "..." --disallowedTools "Bash(git push *)"   # cette commande ne sera jamais exécutée

--tools restreint le jeu d'outils intégrés, et "" les retire tous. --allowedTools ne retire rien, il approuve d'avance les appels indiqués. --disallowedTools avec un nom d'outil seul le sort de la portée de Claude, et avec un motif il ne refuse que les commandes qui correspondent. Je te conseille de raisonner ainsi : d'abord --tools dit quels outils Claude peut atteindre, ensuite --allowedTools dit ce qu'il en fait sans demander.

Une forme imposée par un schéma

Une phrase comme "réponds par une liste" est en général respectée par le modèle, mais un script préfère une garantie. Le drapeau --json-schema accepte un schéma JSON, c'est-à-dire la description des champs que doit avoir le résultat. Enregistre-le dans scripts/review-schema.json :

{
  "type": "object",
  "properties": {
    "findings": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "file": { "type": "string" },
          "line": { "type": "integer" },
          "problem": { "type": "string" },
          "fix": { "type": "string" }
        },
        "required": ["file", "line", "problem", "fix"]
      }
    }
  },
  "required": ["findings"]
}

Le schéma dit : un objet avec un tableau findings, et dedans chaque problème avec un fichier, un numéro de ligne, une description et une correction. Ce fichier ne lance rien, il décrit seulement une forme. Voici maintenant l'exécution qui l'utilise :

git diff --cached | claude -p "Relis ces changements avant le commit : bugs et sécurité." \
  --model sonnet --tools "" --output-format json \
  --json-schema "$(cat scripts/review-schema.json)" | jq -c '.structured_output.findings[]'

La réponse conforme au schéma arrive dans le champ structured_output, et jq -c écrit chaque problème sur une ligne JSON. Chez nous, quatre problèmes sont sortis, avec les mêmes lignes 9 et 13. La documentation prévient que, si l'exécution se termine sans résultat valide, le champ structured_output n'existera pas, donc vérifie-le avant que ton script ne fasse confiance au nombre.

Modèle, connexion et --bare

Sans --model, le script prend le modèle par défaut de tes réglages, c'est-à-dire le dernier choix de /model. Notre première exécution de revue est partie sans ce drapeau et sans --tools "" : le modèle le plus cher des réglages a lu des fichiers, épuisé --max-turns 3, s'est terminé en erreur sans réponse et, selon notre estimation, a coûté plus de cinq fois plus que l'exécution avec --model sonnet.

La connexion fonctionne aussi autrement dans un script. Quand ANTHROPIC_API_KEY est présente dans l'environnement, le mode -p utilise toujours la clé, donc tu paies les tokens malgré l'abonnement. claude auth status --text montre avec quoi tu es connecté. Pour une CI sur abonnement, claude setup-token affiche un jeton de longue durée que tu mets dans le secret CLAUDE_CODE_OAUTH_TOKEN, comme dans la leçon 12_7.

Le drapeau --bare ignore les hooks, les skills, les subagents, les plugins, les serveurs MCP, la mémoire automatique et CLAUDE.md, donc l'exécution fait la même chose sur chaque machine. Il ne lit en revanche ni ta connexion ni CLAUDE_CODE_OAUTH_TOKEN : il demande ANTHROPIC_API_KEY ou apiKeyHelper, c'est-à-dire un paiement aux tokens. C'est un drapeau pour une CI avec clé API, pas pour un portable sur abonnement. L'autre face de la médaille : sans --bare, une exécution -p dans le dépôt d'un autre lancera les hooks de son .claude/settings.json et connectera les serveurs de son .mcp.json sans aucune question. Lis le dossier .claude/ d'un projet étranger avant de lancer un script dessus.

Des sessions où tu reviens

Une exécution -p est aussi une session. claude -p "..." --continue ajoute la demande suivante à la dernière conversation du dossier, par exemple "maintenant propose une correction pour la ligne 13". Mais claude -c ordinaire saute les sessions de -p, donc tu reviens à une exécution précise par son identifiant :

ID=$(git diff --cached | claude -p "Relis ces changements." --model sonnet --output-format json | jq -r '.session_id')
claude -p "Propose une correction pour la ligne 13." --resume "$ID"

La première ligne enregistre l'identifiant de session du champ session_id, la seconde ajoute une nouvelle demande à la même conversation, avec toute la revue dans l'historique, même depuis un autre dossier. Quand tu veux montrer à Claude un second projet, par exemple les tests du clone Spotify, ajoute --add-dir ../sea-shanty-sounds à la fin de la commande, après la demande : le drapeau accepte plusieurs dossiers et tout ce qui le suit sera pris pour des chemins.

Étape suivante

Enferme la revue dans un script pour ne pas la retaper chaque jour. Dans une session Claude Code, écris :

Enregistre la revue par pipe sous scripts/code-review.sh. Quand la zone de préparation
est vide, le script doit afficher un conseil et s'arrêter sans appeler Claude.
Ce sera fini quand : le script a cette vérification et la même commande claude -p que ci-dessus.
Ne le lance pas, je le ferai moi-même dans le terminal.

Dans Cursor, ouvre scripts/code-review.sh et lis ce qui est apparu :

#!/bin/bash
# code-review.sh : revue des changements de la zone de préparation avant de faire un commit

if git diff --cached --quiet; then
  echo "La zone de préparation est vide. D'abord : git add <fichiers>"
  exit 1
fi

git diff --cached | claude -p "Relis ces changements avant le commit : bugs et sécurité.
Réponds uniquement par une liste, une ligne par problème :
fichier:ligne | problème | proposition.
Sans introduction et sans résumé. Si tu ne trouves rien, écris : Rien à signaler." \
  --model sonnet --tools "" --max-turns 2

git diff --cached --quiet n'affiche rien, il se termine seulement en succès quand la zone de préparation est vide, donc le if arrête le script avant que tu paies une revue de rien. --max-turns 2 est un frein au cas où l'exécution s'éterniserait. Ensuite, demande à Claude les corrections de la liste, lance npm run test -- --run et bash scripts/code-review.sh, et signe le commit quand le relecteur répond "Rien à signaler" ou que les remarques restantes, tu les as écartées en connaissance de cause.

Dans l'éditeur à côté, tu assembleras une commande avec pipe et drapeaux, et le simulateur montrera ce qui parvient à Claude, ce qu'il a le droit de faire et qui paie l'exécution.

N'oublie pas : la conversation se tient sur la passerelle, et -p est le quart qui travaille pendant que tu dors, à condition de lui avoir laissé un ordre clair.

Code de cette leçon : App.tsx
// Simulateur de quart : ce qui parvient à Claude en mode -p, ce qu’il a le droit de faire et qui paie
import { useState } from 'react';

type Source = 'cached' | 'worktree' | 'branch';
type Task = 'review' | 'write';
type Tools = 'default' | 'read' | 'none';
type Mode = 'manual' | 'acceptEdits' | 'dontAsk';
type Auth = 'subscription' | 'apiKey' | 'oauthToken';
type Output = 'text' | 'json' | 'schema';

export interface Config {
  task: Task;
  source: Source;
  staged: boolean;
  tools: Tools;
  mode: Mode;
  allowWrite: boolean;
  sonnet: boolean;
  bare: boolean;
  auth: Auth;
  output: Output;
}

export interface Verdict {
  ok: boolean;
  text: string;
}

const PIN_DIFF = [
  '--- a/lib/pinInput.ts',
  '+++ b/lib/pinInput.ts',
  '-    src: z.string().startsWith("/pins/", "L’image doit se trouver dans /pins/."),',
  '+    src: z.union([z.string().startsWith("/pins/"), z.url()], "Image de /pins/ ou adresse complète."),',
];

const BRANCH_DIFF = [
  'commit 1: feat(pins): enregistrement des pins sur les tableaux',
  'commit 2: test(boards): tests de canSavePins',
  '(seulement les commits enregistrés ; les changements d’avant git commit n’y arrivent pas)',
];

const SOURCE_CMD: Record<Source, string> = {
  cached: 'git diff --cached',
  worktree: 'git diff',
  branch: 'git diff main...HEAD',
};

const PROMPT: Record<Task, string> = {
  review: '"Relis ces changements. Réponds par une liste : fichier:ligne | problème | proposition."',
  write: '"Écris des tests Vitest pour @lib/plural.ts et enregistre-les dans lib/plural.test.ts."',
};

export function stdinFor(source: Source, staged: boolean): string[] {
  if (source === 'cached') return staged ? PIN_DIFF : [];
  if (source === 'worktree') return staged ? [] : PIN_DIFF;
  return BRANCH_DIFF;
}

export function buildCommand(c: Config): string {
  const parts: string[] = [];
  if (c.task === 'review') parts.push(SOURCE_CMD[c.source], '|');
  parts.push('claude');
  if (c.bare) parts.push('--bare');
  parts.push('-p', PROMPT[c.task]);
  if (c.sonnet) parts.push('--model sonnet');
  if (c.tools === 'read') parts.push('--tools "Read"');
  if (c.tools === 'none') parts.push('--tools ""');
  if (c.mode !== 'manual') parts.push('--permission-mode ' + c.mode);
  if (c.allowWrite) parts.push('--allowedTools "Write"');
  if (c.output !== 'text') parts.push('--output-format json');
  if (c.output === 'schema') parts.push('--json-schema "$(cat scripts/review-schema.json)"');
  if (c.output === 'json') parts.push("| jq -r '.result'");
  if (c.output === 'schema') parts.push("| jq -c '.structured_output.findings[]'");
  return parts.join(' ');
}

export function inputVerdict(c: Config): Verdict {
  if (c.task === 'write') return { ok: true, text: 'Sans pipe : Claude reçoit seulement la demande et va chercher le fichier lui-même.' };
  const lines = stdinFor(c.source, c.staged);
  if (lines.length === 0) {
    return { ok: false, text: 'Diff vide : Claude reçoit seulement la demande et te parlera de rien avec aplomb.' };
  }
  return { ok: true, text: 'Claude reçoit la demande et ' + lines.length + ' lignes en entrée.' };
}

export function toolsVerdict(c: Config): Verdict {
  const write = c.task === 'write';
  if (c.tools === 'none') {
    return { ok: !write, text: 'Aucun outil : Claude voit seulement la demande et l’entrée, et répond en un seul tour.' + (write ? ' Il n’écrira pas le fichier.' : '') };
  }
  if (c.tools === 'read') {
    return { ok: !write, text: 'Seulement Read : Claude lit les fichiers du projet.' + (write ? ' L’outil Write n’est pas dans le jeu, donc il n’écrira pas le fichier.' : '') };
  }
  if (!write) return { ok: true, text: 'Jeu d’outils complet : Claude peut lire le projet et lancer des commandes en lecture seule.' };
  if (c.allowWrite) return { ok: true, text: 'Write approuvé par --allowedTools : lib/plural.test.ts est créé sans demande.' };
  if (c.mode === 'acceptEdits') {
    return { ok: true, text: 'acceptEdits : Claude écrit les fichiers du projet sans demander. Lance-le seulement sur un arbre Git propre.' };
  }
  return { ok: false, text: 'Écriture refusée : Write atterrit dans permission_denials, le fichier n’existe pas et le code de sortie est 0.' };
}

export function authVerdict(bare: boolean, auth: Auth): Verdict {
  if (bare) {
    if (auth === 'apiKey') return { ok: true, text: '--bare avec une clé API : tu paies les tokens, et les hooks, skills, MCP et CLAUDE.md restent à quai.' };
    return { ok: false, text: '--bare ne lit ni la connexion ni CLAUDE_CODE_OAUTH_TOKEN : sans ANTHROPIC_API_KEY, l’exécution se termine par une erreur.' };
  }
  if (auth === 'apiKey') return { ok: true, text: 'ANTHROPIC_API_KEY en mode -p est toujours utilisée : tu paies les tokens malgré l’abonnement.' };
  if (auth === 'oauthToken') return { ok: true, text: 'Jeton de claude setup-token : l’exécution consomme la limite de l’abonnement.' };
  return { ok: true, text: 'Connexion avec /login : limite de l’abonnement. Sans --bare, les hooks et le .mcp.json du projet démarrent aussi.' };
}

export function outputVerdict(c: Config): Verdict {
  const model = c.sonnet ? 'Sonnet, moins cher, pour la routine. ' : 'Le modèle de tes réglages, c’est-à-dire le dernier choix de /model. ';
  if (c.output === 'text') return { ok: true, text: model + 'Texte brut : agréable pour l’œil, fragile pour un script.' };
  if (c.output === 'json') return { ok: true, text: model + 'La réponse est dans le champ result, avec le coût et permission_denials à côté.' };
  return { ok: true, text: model + 'Résultat conforme au schéma dans le champ structured_output. Vérifie que le champ existe.' };
}

const START: Config = {
  task: 'review',
  source: 'cached',
  staged: true,
  tools: 'none',
  mode: 'manual',
  allowWrite: false,
  sonnet: true,
  bare: false,
  auth: 'subscription',
  output: 'text',
};

function Choice<T extends string>(props: { label: string; value: T; options: [T, string][]; onChange: (v: T) => void }) {
  return (
    <label className="flex flex-col gap-1 text-sm">
      <span className="font-semibold">{props.label}</span>
      <select
        className="rounded border border-slate-600 bg-slate-900 p-1"
        value={props.value}
        onChange={(e) => props.onChange(e.target.value as T)}
      >
        {props.options.map(([v, text]) => (
          <option key={v} value={v}>{text}</option>
        ))}
      </select>
    </label>
  );
}

function Row({ title, verdict }: { title: string; verdict: Verdict }) {
  return (
    <li className="rounded border border-slate-700 p-2">
      <strong className={verdict.ok ? 'text-emerald-400' : 'text-amber-400'}>{title}</strong>
      <p className="text-sm">{verdict.text}</p>
    </li>
  );
}

export default function App() {
  const [c, setC] = useState<Config>(START);
  const set = <K extends keyof Config>(key: K, value: Config[K]) => setC({ ...c, [key]: value });
  const stdin = c.task === 'review' ? stdinFor(c.source, c.staged) : [];

  return (
    <div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
      <h1 className="text-xl font-bold">Le quart sans conversation : claude -p dans Treasure Map</h1>
      <div className="grid gap-3 md:grid-cols-3">
        <Choice label="Tâche" value={c.task} onChange={(v) => set('task', v)} options={[['review', 'Revue du diff'], ['write', 'Écriture du fichier de tests']]} />
        <Choice label="Source du pipe" value={c.source} onChange={(v) => set('source', v)} options={[['cached', 'git diff --cached'], ['worktree', 'git diff'], ['branch', 'git diff main...HEAD']]} />
        <Choice label="Outils (--tools)" value={c.tools} onChange={(v) => set('tools', v)} options={[['default', 'par défaut'], ['read', '"Read"'], ['none', '""']]} />
        <Choice label="Mode de permissions" value={c.mode} onChange={(v) => set('mode', v)} options={[['manual', 'Manual (par défaut avec -p)'], ['acceptEdits', 'acceptEdits'], ['dontAsk', 'dontAsk']]} />
        <Choice label="Connexion" value={c.auth} onChange={(v) => set('auth', v)} options={[['subscription', 'abonnement (/login)'], ['apiKey', 'ANTHROPIC_API_KEY'], ['oauthToken', 'CLAUDE_CODE_OAUTH_TOKEN']]} />
        <Choice label="Résultat" value={c.output} onChange={(v) => set('output', v)} options={[['text', 'texte'], ['json', 'JSON et jq'], ['schema', '--json-schema et jq']]} />
      </div>
      <div className="flex flex-wrap gap-4 text-sm">
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.staged} onChange={(e) => set('staged', e.target.checked)} />j’ai fait git add</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.allowWrite} onChange={(e) => set('allowWrite', e.target.checked)} />--allowedTools "Write"</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.sonnet} onChange={(e) => set('sonnet', e.target.checked)} />--model sonnet</label>
        <label className="flex items-center gap-2"><input type="checkbox" checked={c.bare} onChange={(e) => set('bare', e.target.checked)} />--bare</label>
      </div>
      <pre className="overflow-x-auto whitespace-pre-wrap rounded bg-slate-900 p-2 font-mono text-xs">{buildCommand(c)}</pre>
      <section>
        <h2 className="font-semibold">Ce qui arrive en entrée</h2>
        <pre className="rounded bg-slate-900 p-2 font-mono text-xs">{stdin.length ? stdin.join('\n') : '(rien)'}</pre>
      </section>
      <ul className="space-y-2">
        <Row title="Entrée" verdict={inputVerdict(c)} />
        <Row title="Outils et écriture" verdict={toolsVerdict(c)} />
        <Row title="Connexion et facture" verdict={authVerdict(c.bare, c.auth)} />
        <Row title="Modèle et résultat" verdict={outputVerdict(c)} />
      </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. Quel drapeau laisse à Claude, dans une exécution claude -p, seulement l'outil Read ?

  2. 2. Un script lance claude -p "Écris des tests Vitest pour @lib/plural.ts et enregistre-les dans lib/plural.test.ts." sans aucun drapeau de permission. Que se passe-t-il ?

Voici 2 des 10 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 dans l'ordre pour construire la commande qui crée un jeton d'abonnement de longue durée pour la CI :

  • Clique dans l'ordre

    Clique sur les éléments dans l'ordre pour ajouter une nouvelle demande à l'exécution dont tu as enregistré l'identifiant dans la variable ID :

  • Tri horizontal

    Range la commande qui envoie à Claude les changements de toute la branche et enregistre la réponse dans un fichier :

  • Tri horizontal

    Range la commande qui impose la forme de la revue par un schéma et écrit chaque problème sur sa propre ligne :

  • Clique dans l'ordre

    Clique sur les éléments dans l'ordre pour construire la commande qui montre en texte lisible avec quoi tes exécutions se connectent :

  • Clique dans l'ordre

    Clique sur les éléments dans l'ordre pour construire une exécution où l'écriture d'un fichier est approuvée d'avance :

  • Éditeur de code

    Dans commands.sh, écris le script code-review.sh : récupère les changements en staging (git diff --cached), envoie-les par un pipe à claude -p et demande-lui de signaler les bugs et les problèmes de sécurité.

  • Clique dans l'ordre

    Clique sur les éléments dans l'ordre pour construire une exécution où Claude ne voit que la demande et l'entrée du pipe :

  • Tri horizontal

    Range la commande qui donne à Claude un aperçu d'un second projet (rappelle-toi que --add-dir accepte plusieurs dossiers) :

  1. QuestionQuiz : Le jeu d'outils en mode -p
  2. QuestionQuiz : Écrire un fichier sans permission avec -p
  3. Clique dans l'ordreClic dans l'ordre : Jeton d'abonnement pour la CI
  4. QuestionQuiz : Le drapeau --bare
  5. Clique dans l'ordreClic dans l'ordre : Revenir à une exécution par son identifiant
  6. Remets dans l'ordreTri : Le diff d'une branche dans un fichier
  7. Remets dans l'ordreTri : Revue avec un schéma JSON
  8. QuestionQuiz : ANTHROPIC_API_KEY en mode -p
  9. QuestionQuiz : Le projet d'un autre et le mode -p
  10. Clique dans l'ordreClic dans l'ordre : Vérifier la connexion
  11. QuestionQuiz : Le diff de la zone de préparation
  12. QuestionQuiz : Un diff vide
  13. Clique dans l'ordreClic dans l'ordre : Écriture approuvée en -p
  14. Exercice de codePratique : script de revue avant le commit
  15. QuestionQuiz : La forme de la réponse
  16. QuestionQuiz : Le modèle dans un script
  17. Clique dans l'ordreClic dans l'ordre : Exécution sans outils
  18. QuestionQuiz : Revenir à une exécution -p
  19. Remets dans l'ordreTri : Un second projet avec --add-dir

Articles utiles