Cours Vibe coding avec Claude Code · Module 15: Claude Code avancé
Travail parallèle et en arrière-plan : worktree, tâches de fond, /batch, /loop et /schedule
Dans cette leçon10
Deux fonctionnalités attendent dans la liste de Treasure Map. La première, ce sont les tableaux partagés : le propriétaire invite des collaborateurs sur un tableau, et ils y posent leurs pins. Le champ collaboratorIds existe sur le tableau depuis la leçon 13_2, il ne manque que les invitations. La seconde, c'est une meilleure loupe : la recherche par photo ne compare aujourd'hui que la couleur dominante, alors qu'elle pourrait aussi peser les tags des pins. Les deux fonctionnalités ne dépendent pas l'une de l'autre, mais dans une seule session elles font la queue : la deuxième attend la fin de la première, et les détails des deux se mélangent dans la conversation. Cette leçon montre quand répartir le travail entre plusieurs sessions, comment le laisser tourner en arrière-plan et à qui confier l'horloge.
Ce que tu sais déjà
Dans la leçon 9_2, tu as mis à l'eau deux chaloupes, claude -w sons et claude -w enregistreur, chacune dans le dossier .claude/worktrees/<nom>/ sur la branche worktree-<nom>, et tu as vu un conflit quand deux branches ont ajouté quelque chose au même endroit de lib/format.ts. Dans la leçon 6_4, tu as envoyé un serveur en arrière-plan avec Ctrl+B et tu l'as regardé dans /tasks, et de la leçon 5_10 tu sais que chaque subagent paie sur la même limite que la conversation. De la leçon 14_6, tu connais les sessions dans le cloud, et de la leçon 14_7 l'exécution claude -p --worktree, après laquelle le worktree reste verrouillé. Ici, tu ajoutes ce qu'il te faut quand les tâches parallèles se multiplient et que tu n'es pas à côté d'elles.
D'abord la carte des fichiers
Deux sessions dans deux worktree ne s'écrasent pas leurs fichiers, mais à la fusion des branches un fichier commun finit quand même par remonter. Avant de mettre les chaloupes à l'eau, vérifie donc qu'elles filent vers des baies différentes. Fais-le en mode planification, où Claude se contente de lire le projet :
Demande pour Claude Code (mode planification) :
N'écris pas de code. Deux fonctionnalités de Treasure Map : (1) invitations à un tableau,
(2) recherche par photo qui compare, en plus de la couleur, les tags des pins. Pour chacune,
liste les fichiers qu'elle modifiera ou créera et indique si elle demande une migration de la
base ou un nouveau paquet npm. À la fin, donne les fichiers communs aux deux fonctionnalités.Une liste à la place du code coûte peu et dit tout de suite si le travail peut avancer en parallèle. Un bon plan ressemble à peu près à ceci :
1. Invitations : lib/boards.ts, app/api/boards/[id]/collaborators/route.ts (nouveau),
components/InviteDialog.tsx (nouveau), app/boards/[id]/page.tsx. Sans migration ni paquet.
2. Loupe : lib/visualSearch.ts, app/api/visual-search/route.ts, components/CameraSearch.tsx.
Sans migration ni paquet.
Fichiers communs : aucun.Une liste vide de fichiers communs, c'est le feu vert. Trois cas te retiennent au port, même quand les fichiers ne se recoupent pas. Le premier, ce sont deux migrations : les deux chaloupes recevront le même .env, donc la même base, et tu changes le schéma d'abord, à part, dans le dossier principal. Le deuxième, ce sont deux nouveaux paquets, car les deux branches modifieront package.json et package-lock.json. Le troisième, c'est la dépendance : quand une fonctionnalité a besoin du résultat de l'autre, elles avancent l'une après l'autre.
Deux chaloupes, un seul .env
Dans la leçon 14_7, le worktree est parti sans .env, parce que les tests n'en avaient pas besoin. Les invitations, elles, lisent la base, donc cette fois le fichier doit embarquer avec l'équipage. C'est le rôle de .worktreeinclude, à la racine du projet, avec la syntaxe de .gitignore :
.envClaude Code copie dans chaque nouveau worktree les fichiers qui correspondent au motif et qui sont ignorés par Git, et il ne duplique jamais les fichiers suivis. Chez nous, après l'ajout de cette seule ligne, l'exécution claude -p --worktree tableaux a trouvé dans le worktree un .env identique à l'original. Le motif ne couvre que .env, donc chaque session installe node_modules elle-même, comme le client Prisma : le dossier app/generated/prisma est dans .gitignore, donc un checkout neuf ne l'a pas. Maintenant, deux terminaux dans Cursor, une commande dans chacun :
claude -w tableaux
claude -w rechercheUn projet sans dépôt distant démarre le worktree à partir de ton commit courant. Avec un dépôt sur GitHub, il part de la branche par défaut du remote : tu fais donc un push, comme dans la leçon 9_2, ou tu règles dans les paramètres "worktree": { "baseRef": "head" }. Dans la session des tableaux, tu donnes une demande avec une frontière claire :
Demande pour Claude Code (session tableaux) :
Tu travailles dans un worktree sur les invitations aux tableaux. D'abord npm install et npx prisma generate.
Seul le propriétaire d'un tableau ajoute un collaborateur : la route app/api/boards/[id]/collaborators/route.ts
avec un schéma Zod et un 403 pour les autres, la fenêtre components/InviteDialog.tsx sur la page du tableau.
Sans migration et sans nouveaux paquets. Ne touche pas à lib/visualSearch.ts, app/api/visual-search
ni components/CameraSearch.tsx. À la fin, tests, lint et tsc, puis un commit.La deuxième session reçoit la demande en miroir : ses fichiers de la carte et l'interdiction d'entrer dans ceux des tableaux.
Quand une session a fait son commit, tu en sors, et Claude Code te demande quoi faire du worktree qui contient du travail. Choisis de le garder. La suppression efface le dossier avec la branche et ses commits, et ce travail n'est pas encore dans main.
Les chaloupes reviennent
Avant de fusionner quoi que ce soit, compare les listes de fichiers modifiés des deux branches. Dans le terminal du dossier principal :
comm -12 <(git diff --name-only main...worktree-tableaux | sort) <(git diff --name-only main...worktree-recherche | sort)git diff --name-only affiche les fichiers modifiés sur la branche depuis sa séparation de main, et comm -12 ne garde que les lignes présentes dans les deux listes. Un résultat vide signifie que les branches n'ont modifié aucun fichier commun, donc Git ne signalera pas de conflit. Dans un dépôt d'essai où les deux branches avaient touché lib/types.ts, la commande a affiché exactement ce seul chemin. La syntaxe <(...) fonctionne dans bash et zsh, mais pas dans PowerShell, le terminal par défaut de Cursor sous Windows : là, lance la commande dans Git Bash ou demande à Claude de comparer les deux listes. Tu fusionnes ensuite l'une après l'autre, comme dans la leçon 9_2.
Après la fusion, le rangement. Les worktrees gardés à la sortie, tu les supprimes toi-même. Le worktree d'une exécution -p est en plus verrouillé : chez nous, git worktree remove a répondu cannot remove a locked working tree. La séquence complète a donc trois commandes, et la première ne sert qu'en cas de verrou :
git worktree unlock .claude/worktrees/tableaux
git worktree remove .claude/worktrees/tableaux
git branch -d worktree-tableauxLe .env copié n'empêche pas la suppression, car Git l'ignore. git branch -d ne supprime qu'une branche déjà fusionnée, donc il n'effacera pas un travail que tu n'as pas encore versé.
Toute la session en arrière-plan
Ctrl+B de la leçon 6_4 envoie en arrière-plan une commande ou un subagent. La commande /background (en plus court /bg) détache toute la session : elle continue à travailler comme agent de fond, et le terminal te revient. Tu démarres une nouvelle session de fond depuis le shell avec claude --bg "tâche", et tu les vois toutes sur un seul écran avec claude agents, encore en phase de test (research preview). Une session lancée par claude --bg passe dans son propre worktree avant de modifier quoi que ce soit. Une session renvoyée en arrière-plan par /background continue d'éditer là où elle travaillait, donc envoyée depuis le dossier principal, elle n'a aucune isolation.
/batch : un seul changement, beaucoup de fichiers
Pour un grand changement mécanique dans beaucoup de fichiers, il y a le skill intégré /batch. Selon la documentation, Claude commence par étudier le projet, découpe le travail en unités indépendantes et te montre un plan. Après ton accord, chaque unité reçoit un subagent de fond et son propre worktree, et le subagent fait le changement, lance les tests et ouvre une pull request ou rapporte ce qu'il a fait. Cela ressemble à ceci :
/batch ajoute à chaque composant de components/ un test de rendu Vitest à côté du fichier du composantC'est un bon candidat : même changement, chaque test dans un fichier à part, chacun vérifiable séparément. Avec sept composants de Treasure Map, c'est pourtant un canon pour tuer une mouche, car une seule session le fera pour moins cher, et /batch ne se rentabilise qu'avec des dizaines de fichiers. N'y recours pas quand les unités touchent un fichier commun, quand le changement demande une décision de conception ou quand le projet n'a pas de tests avec lesquels le subagent vérifierait sa part. Rappelle-toi aussi que les worktree des subagents démarrent comme claude -w, donc avec un dépôt sur GitHub, à partir de la branche du remote.
/loop et /schedule : qui surveille l'horloge
/loop répète une demande dans la session ouverte : à intervalle fixe ou à un rythme que Claude choisit lui-même. Par exemple, un point sur les chaloupes :
/loop 10m vérifie git log -1 --oneline sur les branches worktree-tableaux et worktree-recherche et dis-moi quelle session a déjà fait un commitChaque répétition est un nouveau tour qui renvoie toute la conversation, même quand rien n'a changé, donc ne laisse pas une boucle dans une longue session. La boucle ne tourne que si la session est ouverte, et une tâche récurrente expire au bout de sept jours (état de novembre 2026). Une boucle à intervalle, tu l'arrêtes en demandant à Claude de l'annuler, et une boucle au rythme de Claude avec la touche Esc.
/schedule crée une tâche récurrente dans le cloud, appelée autrefois routine. Chaque exécution est une session Claude Code complète sur un clone neuf du dépôt GitHub : elle tourne donc ordinateur fermé, mais ne voit pas tes fichiers non commités. Elle exige une connexion avec un compte claude.ai, et non une clé API, elle pousse les changements sur des branches préfixées par claude/, et la documentation conseille de protéger d'abord main par une règle de branche sur GitHub. Aujourd'hui, tu ne crées rien : d'abord le dépôt et la règle pour main, puis les premières exécutions sous tes yeux.
/loop | /schedule | |
|---|---|---|
| Où elle travaille | dans ta session ouverte | dans le cloud d'Anthropic |
| Ordinateur éteint | la boucle s'arrête | la tâche tourne |
| Fichiers | ton dossier, y compris le non commité | clone neuf depuis GitHub |
| Pour quoi | une courte surveillance pendant le travail | des tâches fixes chaque nuit ou chaque semaine |
Le coût du parallélisme
Chaque session, session de fond, subagent et unité de /batch envoie ses propres requêtes et paie sur la même limite du plan. La documentation le dit sans détour : dix agents de fond consomment la limite environ dix fois plus vite qu'un seul. Le parallélisme achète du temps, pas des économies, donc tu ne le lances que là où l'attente fait vraiment mal.
La revue du capitaine
- Une carte sans partie commune.
comm -12de la section ci-dessus n'affiche rien. - Une seule base. Les deux sessions ont le même
DATABASE_URL, donc dans le diff d'aucune branche il n'y a de nouveau dossier dansprisma/migrations/. - Les paquets. Au plus une branche a modifié
package.jsonetpackage-lock.json. - Après la traversée.
git worktree listne montre plus que le dossier principal.
L'erreur typique de l'agent : deux tâches parallèles touchent aux mêmes fichiers. La session des tableaux ajoute "au passage" un lien de navigation dans app/layout.tsx ou un champ dans le type Pin de lib/types.ts, et l'autre session fait la même chose à sa manière. Tu la reconnais au résultat de comm -12 ou à ce fichier dans le diff des deux branches dans Cursor. Le changement commun, tu le retires d'une des branches et tu le fais après la fusion, dans une seule session.
Étape suivante
Dans une session du dossier principal, écris : "Verse dans main les branches worktree-tableaux et worktree-recherche, l'une après l'autre, puis tests, lint et tsc". La fusion enregistre l'historique toute seule, donc tu ne demandes un commit que si les tests ont imposé des corrections, par exemple "Corrections après la fusion des tableaux et de la loupe". Pour finir, range les chaloupes. Dans l'éditeur à côté, tu saisiras les fichiers de deux tâches, et le vérificateur te dira si elles peuvent avancer en parallèle et te donnera les commandes.
N'oublie pas : tu mets les chaloupes à l'eau ensemble seulement quand chacune file vers une autre baie, et tu confies l'horloge à celui qui sera à bord quand l'heure sonnera.
Code de cette leçon : App.tsx
// Chaloupes ou file d’attente : deux tâches de Treasure Map peuvent-elles avancer en parallèle, et qui surveille l’horloge
import { useState } from 'react';
export type Level = 'ok' | 'warn' | 'error';
export interface Finding {
level: Level;
text: string;
}
export interface Task {
name: string;
files: string;
migration: boolean;
packages: boolean;
}
export interface Verdict {
parallel: boolean;
findings: Finding[];
commands: string[];
}
export const SHARED = ['app/layout.tsx', 'lib/types.ts', 'package.json', 'package-lock.json', 'prisma/schema.prisma'];
const ACCENTS: Record<string, string> = { à: 'a', â: 'a', ç: 'c', é: 'e', è: 'e', ê: 'e', ë: 'e', î: 'i', ï: 'i', ô: 'o', ù: 'u', û: 'u', ü: 'u' };
export function slug(name: string): string {
const ascii = name.toLowerCase().split('').map((ch) => ACCENTS[ch] ?? ch).join('');
const s = ascii.replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
return s === '' ? 'tache' : s;
}
export function parseFiles(text: string): string[] {
const out: string[] = [];
for (const raw of text.split(/[,\n]/)) {
let f = raw.trim();
if (f.startsWith('./')) f = f.slice(2);
if (f !== '' && !out.includes(f)) out.push(f);
}
return out;
}
function touches(a: string, b: string): boolean {
if (a === b) return true;
if (a.endsWith('/') && b.startsWith(a)) return true;
return b.endsWith('/') && a.startsWith(b);
}
export function overlap(a: string[], b: string[]): string[] {
const out: string[] = [];
for (const fa of a) {
for (const fb of b) {
if (touches(fa, fb)) {
const shorter = fa.length <= fb.length ? fa : fb;
if (!out.includes(shorter)) out.push(shorter);
}
}
}
return out.sort();
}
export function check(a: Task, b: Task, dependent: boolean): Verdict {
const fa = parseFiles(a.files);
const fb = parseFiles(b.files);
const findings: Finding[] = [];
if (fa.length === 0 || fb.length === 0) {
findings.push({ level: 'warn', text: 'Pas de carte des fichiers. Demande à Claude, en mode planification, la liste des fichiers de chaque tâche.' });
}
const common = overlap(fa, fb);
if (common.length > 0) {
findings.push({ level: 'error', text: 'Fichiers communs : ' + common.join(', ') + '. À la fusion, un conflit remontera ou une version écrasera l’autre.' });
}
for (const s of SHARED) {
const inA = fa.includes(s);
const inB = fb.includes(s);
if (inA !== inB) {
findings.push({ level: 'warn', text: s + ' est un fichier de toute l’application. Mieux vaut le modifier après la fusion, dans une seule session.' });
}
}
if (a.migration && b.migration) {
findings.push({ level: 'error', text: 'Deux migrations, et le .env de .worktreeinclude donne aux deux sessions la même base. Les changements de schéma, l’un après l’autre, dans le dossier principal.' });
} else if (a.migration || b.migration) {
findings.push({ level: 'warn', text: 'Une migration dans un worktree touchera la même base que le dossier principal. Fais-la avant de répartir le travail.' });
}
if (a.packages && b.packages) {
findings.push({ level: 'error', text: 'Les deux branches modifieront package.json et package-lock.json.' });
}
if (dependent) {
findings.push({ level: 'error', text: b.name + ' a besoin du résultat de la tâche ' + a.name + ', donc elles avancent l’une après l’autre.' });
}
const parallel = !findings.some((f) => f.level === 'error') && fa.length > 0 && fb.length > 0;
if (parallel) {
findings.push({ level: 'ok', text: 'Des baies différentes : chaque tâche peut avoir son propre worktree.' });
}
const wa = 'worktree-' + slug(a.name);
const wb = 'worktree-' + slug(b.name);
const commands = parallel
? [
'claude -w ' + slug(a.name) + ' # terminal 1',
'claude -w ' + slug(b.name) + ' # terminal 2',
'comm -12 <(git diff --name-only main...' + wa + ' | sort) <(git diff --name-only main...' + wb + ' | sort)',
]
: ['claude # une seule session : d’abord ' + a.name + ', commit, puis ' + b.name];
return { parallel, findings, commands };
}
export type ClockTool = '/loop' | '/schedule' | 'rien';
export function clockTool(laptopOff: boolean, needsLocal: boolean): { tool: ClockTool; text: string } {
if (laptopOff && needsLocal) {
return { tool: 'rien', text: 'Contradiction : le cloud ne voit pas les fichiers non commités, et /loop ne marche pas sans ta session. Fais un commit et un push, ou laisse l’ordinateur allumé.' };
}
if (laptopOff) {
return { tool: '/schedule', text: 'Une tâche dans le cloud sur un clone neuf depuis GitHub. Connexion avec un compte claude.ai, changements sur des branches claude/, d’abord une règle qui protège main.' };
}
return { tool: '/loop', text: 'Des répétitions dans la session ouverte. Chacune renvoie toute la conversation : ne laisse donc pas une boucle dans une longue session. Tu l’arrêtes en demandant de l’annuler.' };
}
const TABLEAUX = 'lib/boards.ts\napp/api/boards/[id]/collaborators/route.ts\ncomponents/InviteDialog.tsx\napp/boards/[id]/page.tsx';
const LOUPE = 'lib/visualSearch.ts\napp/api/visual-search/route.ts\ncomponents/CameraSearch.tsx';
export const PRESETS: Record<string, { a: Task; b: Task; dependent: boolean }> = {
'Invitations et loupe': {
a: { name: 'tableaux', files: TABLEAUX, migration: false, packages: false },
b: { name: 'recherche', files: LOUPE, migration: false, packages: false },
dependent: false,
},
'Erreur de l’agent : type commun': {
a: { name: 'tableaux', files: TABLEAUX + '\nlib/types.ts\napp/layout.tsx', migration: false, packages: false },
b: { name: 'recherche', files: LOUPE + '\nlib/types.ts', migration: false, packages: false },
dependent: false,
},
'Deux migrations': {
a: { name: 'tableaux', files: TABLEAUX + '\nprisma/schema.prisma', migration: true, packages: false },
b: { name: 'favoris', files: 'lib/favorites.ts\napp/api/favorites/route.ts\nprisma/schema.prisma', migration: true, packages: false },
dependent: false,
},
'Tâche dépendante': {
a: { name: 'tableaux', files: TABLEAUX, migration: false, packages: false },
b: { name: 'notifications', files: 'lib/notifications.ts\ncomponents/InviteBadge.tsx', migration: false, packages: false },
dependent: true,
},
};
const LEVEL_CLASS: Record<Level, string> = {
ok: 'text-emerald-400',
warn: 'text-amber-400',
error: 'text-rose-400',
};
function TaskForm(props: { title: string; task: Task; onChange: (t: Task) => void }) {
const t = props.task;
return (
<fieldset className="space-y-2 rounded border border-slate-700 p-3">
<legend className="px-1 font-semibold">{props.title}</legend>
<label className="block text-sm">
Nom (fin du nom de la branche)
<input className="mt-1 w-full rounded bg-slate-900 p-1 font-mono" value={t.name} onChange={(e) => props.onChange({ ...t, name: e.target.value })} />
</label>
<label className="block text-sm">
Fichiers, un par ligne (un dossier se termine par /)
<textarea className="mt-1 h-28 w-full rounded bg-slate-900 p-2 font-mono text-xs" value={t.files} onChange={(e) => props.onChange({ ...t, files: e.target.value })} />
</label>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={t.migration} onChange={(e) => props.onChange({ ...t, migration: e.target.checked })} />
migration de la base
</label>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={t.packages} onChange={(e) => props.onChange({ ...t, packages: e.target.checked })} />
nouveau paquet npm
</label>
</fieldset>
);
}
export default function App() {
const start = PRESETS['Invitations et loupe'];
const [a, setA] = useState<Task>(start.a);
const [b, setB] = useState<Task>(start.b);
const [dependent, setDependent] = useState(start.dependent);
const [laptopOff, setLaptopOff] = useState(false);
const [needsLocal, setNeedsLocal] = useState(true);
const verdict = check(a, b, dependent);
const clock = clockTool(laptopOff, needsLocal);
return (
<div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
<h1 className="text-xl font-bold">Chaloupes ou file d’attente ?</h1>
<div className="flex flex-wrap gap-2 text-sm">
{Object.keys(PRESETS).map((name) => (
<button
key={name}
type="button"
className="rounded bg-slate-800 px-2 py-1 hover:bg-slate-700"
onClick={() => {
setA(PRESETS[name].a);
setB(PRESETS[name].b);
setDependent(PRESETS[name].dependent);
}}
>
{name}
</button>
))}
</div>
<div className="grid gap-3 md:grid-cols-2">
<TaskForm title="Tâche A" task={a} onChange={setA} />
<TaskForm title="Tâche B" task={b} onChange={setB} />
</div>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={dependent} onChange={(e) => setDependent(e.target.checked)} />
B a besoin du résultat de A
</label>
<p role="status" className={'text-lg font-semibold ' + (verdict.parallel ? 'text-emerald-400' : 'text-rose-400')}>
{verdict.parallel ? 'En parallèle : deux worktree' : 'À la suite : une seule session'}
</p>
<ul className="space-y-1 text-sm">
{verdict.findings.map((f) => (
<li key={f.text} className={LEVEL_CLASS[f.level]}>{f.level}: {f.text}</li>
))}
</ul>
<pre className="overflow-x-auto whitespace-pre-wrap rounded bg-slate-900 p-2 font-mono text-xs">{verdict.commands.join('\n')}</pre>
<section className="space-y-2 rounded border border-slate-700 p-3">
<h2 className="font-semibold">Qui surveille l’horloge</h2>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={laptopOff} onChange={(e) => setLaptopOff(e.target.checked)} />
doit tourner quand le portable est fermé
</label>
<label className="flex items-center gap-2 text-sm">
<input type="checkbox" checked={needsLocal} onChange={(e) => setNeedsLocal(e.target.checked)} />
a besoin des fichiers non commités de mon dossier
</label>
<p className="text-sm">
<strong className="font-mono">{clock.tool}</strong>: {clock.text}
</p>
</section>
</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. Que donne le lancement de claude -w tableaux dans le projet Treasure Map ?
2. Chaque nuit, un rapport des tâches ouvertes du dépôt Treasure Map sur GitHub doit être produit, même quand l'ordinateur portable est fermé. Que vas-tu utiliser ?
Voici 2 des 3 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Tri horizontal
Compose la commande qui, après la fusion et le déverrouillage, supprime le worktree tableaux :
- Clique dans l'ordre
Clique les éléments dans l'ordre pour confier un seul grand changement mécanique dans beaucoup de fichiers, chaque part dans son propre worktree :