Cours Vibe coding avec Claude Code · Module 15: Claude Code avancé
Un filet pour le travail sans surveillance : mode auto, règles deny et sandbox
Dans cette leçon9
Les routes API de Treasure Map signalent les erreurs chacune à sa façon : six fichiers, quinze Response.json({ error: ... }) écrits à la main, et des tests pour deux routes seulement. Les déplacer vers un module commun lib/apiErrors.ts et ajouter les tests manquants, c'est une heure de travail mécanique, parfaite pour un soir où tu quittes le pont. Sauf que pendant cette heure, personne ne cliquera sur "Yes". En mode Manual, l'exécution s'arrêtera à la première question, et en bypassPermissions, rien ne l'arrêtera plus. Il te faut une troisième voie : des limites que garde un programme, pas ta présence devant le clavier.
Ce que tu sais déjà
Les modes de permission et Shift+Tab, tu les connais depuis la leçon 0_4, et Esc, /rewind et le commit comme ancre depuis la leçon 0_6. Dans la leçon 8_4, tu as fermé .env avec une règle deny et tu as vu ses limites, dans la leçon 10_5 tu as appris que le classificateur du mode auto bloque les déploiements en production, et dans la leçon 12_4 que bypassPermissions n'a de sens que dans un conteneur. De la leçon 9_2, tu connais le worktree et claude -w, de la leçon 14_1 les exécutions claude -p et le champ permission_denials, et des leçons 14_3 et 14_5 l'ordre deny, ask, allow et le hook PreToolUse. Aujourd'hui, tu tresses ces cordages en un seul filet pour un quart sans capitaine.
Qui veille quand tu n'es pas là
Chaque appel d'outil passe par une file fixe. D'abord tes règles deny, ask et allow et les hooks PreToolUse, puis les lectures et les modifications de fichiers dans le dossier du projet, que le mode auto laisse passer tout de suite, et tout le reste va au classificateur. Le sandbox se tient derrière cette file et limite la commande du shell pendant qu'elle s'exécute.
| Couche | Qui veille | Ce qu'elle ne rattrape pas |
|---|---|---|
règle deny ou ask, hook | Claude Code, toujours de la même façon | une commande écrite autrement que le motif, un script qui ouvre lui-même le fichier |
| classificateur du mode auto | un modèle à part | peut se tromper dans les deux sens |
| sandbox | le système d'exploitation | les outils de fichiers de Claude, les serveurs MCP et les hooks |
| commit et worktree | Git | n'arrête rien, mais permet d'annuler chaque changement dans les fichiers |
Aucune couche ne suffit seule, car chacune a un trou que la suivante rebouche. Pour un quart sans capitaine, tu tends les quatre.
Le classificateur de près
La liste des blocages par défaut est plus longue que les déploiements de la leçon 10_5. Le classificateur arrête entre autres le téléchargement et l'exécution de code étranger (curl | bash), le force push, la suppression irréversible de fichiers qui existaient avant la session, des commandes comme git reset --hard, qui pourraient jeter un travail non commité, l'envoi de données sensibles vers l'extérieur et le lancement d'un autre agent sans accord et sans sandbox. En revanche, il laisse passer les opérations sur les fichiers du dossier du projet, l'installation des dépendances depuis le fichier de verrouillage, le push vers n'importe quelle branche de ton dépôt, y compris main, et la lecture de .env. Toute la liste, la commande l'affiche :
claude auto-mode defaultsLa commande ne change rien, elle imprime les règles en JSON, chacune dans une phrase ordinaire en anglais. Lis-la une fois avant de faire confiance au mode auto pour la nuit. Garde en tête la file du début de la leçon : la lecture de .env dans le dossier du projet n'arrive même pas au classificateur, car le mode auto laisse passer ces lectures tout de suite, donc le seul rempart reste ta règle deny.
Plus important que la liste, ce qui se passe après un blocage. Dans une session où tu es présent, l'action bloquée arrive dans l'onglet Recently blocked de /permissions, et après trois blocages de suite ou vingt au total, le mode auto se met en pause et Claude Code te redemande. Dans une exécution claude -p, il n'y a personne à interroger, et la documentation le dit tout net : l'action ne s'exécute pas, Claude continue de travailler et l'exécution ne s'arrête pas. Le matin, tu ne la verras que dans permission_denials.
Le classificateur se configure avec le bloc autoMode : des phrases ordinaires sur l'infrastructure de confiance (environment) et sur les exceptions (allow). Claude Code ne le lit que dans ~/.claude/settings.json, dans les réglages de l'organisation et dans le drapeau --settings, et pas dans le .claude/settings.json du projet, pour qu'un dépôt cloné ne puisse pas desserrer ses propres règles. Le classificateur lit en revanche CLAUDE.md, donc la phrase "ne fais jamais de force push" oriente à la fois Claude et le jugement. Pour Treasure Map, tu n'ajoutes rien ici, car les règles par défaut conviennent à un projet sur un seul ordinateur. Retiens l'avertissement de la documentation : le mode auto réduit le nombre de questions, mais ne garantit pas la sécurité. Ce qui n'est jamais permis, tu l'écris en règle.
Demande pour Claude Code
L'exécution de nuit aura son propre fichier de réglages, donné avec le drapeau --settings, si bien que tes sessions de jour resteront comme avant. Dans une session ouverte dans le dossier treasure-map, écris :
Prépare les réglages du quart de nuit. Crée scripts/quart-de-nuit.json uniquement pour les
exécutions sans surveillance : sandbox activé, pas de nouvelle tentative de commande hors sandbox,
réseau seulement vers registry.npmjs.org, sans exception. Dans .claude/settings.json, ajoute à deny la règle
Bash(npx prisma migrate reset *), ne supprime rien. Montre le diff des deux fichiers.
Pas de commit, je les vérifierai moi-même.La demande dit quel fichier naît, ce qu'il doit contenir et ce qu'on ne touche pas, donc Claude n'a rien à deviner.
Ce que Claude a écrit
Ouvre scripts/quart-de-nuit.json dans Cursor. Tout le fichier tient dans une seule clé, sandbox :
{
"sandbox": {
"enabled": true,
"allowUnsandboxedCommands": false,
"network": {
"allowedDomains": ["registry.npmjs.org"],
"strictAllowlist": true
}
}
}enabled active le sandbox, c'est-à-dire une frontière que le système d'exploitation dresse pour les commandes du shell : sur macOS le mécanisme Seatbelt, sur Linux et WSL2 bubblewrap, et sur Windows natif le sandbox ne fonctionne pas du tout. Les commandes n'écrivent alors que dans le dossier de travail et dans le dossier temporaire, et elles sortent vers le réseau par un intermédiaire qui vérifie les domaines de allowedDomains. Un seul suffit, car un worktree tout neuf a besoin de npm install. strictAllowlist: true ferme la porte dérobée : sans lui, en mode auto, Claude peut ajouter un domaine à la commande et le classificateur l'approuver, alors qu'avec lui l'intermédiaire refuse tout domaine hors de la liste, dans tous les modes. Cette clé fonctionne depuis le drapeau --settings et depuis les réglages utilisateur, pas depuis le fichier du projet. Les commandes peuvent pourtant lire presque tout le disque, y compris ~/.ssh, et c'est pourquoi le réseau fermé compte le plus ici : une clé lue n'a nulle part où sortir. allowUnsandboxedCommands: false est le mode strict, où Claude ne peut pas relancer hors du sandbox une commande refusée. Dans une session ordinaire, le même sandbox s'active avec /sandbox de la leçon 12_4, qui enregistre le choix dans .claude/settings.local.json ; le fichier donné par le drapeau ne vaut que pour une exécution.
Dans .claude/settings.json, une seule ligne a changé :
"deny": ["Read(./.env)", "Read(./.env.*)", "Bash(npx prisma migrate reset *)"]Le reset vide toute la base de développement, et l'agent le tente quand l'historique des migrations cesse de lui convenir. La règle ask de la leçon 14_3 le couvrait aussi, mais deny ne demande rien du tout et vaut dans tous les modes. L'espace avant l'étoile fait que la règle attrape le reset avec n'importe quelle option, --force compris.
Départ du quart : commit, worktree, limites
Avant d'appareiller, demande à Claude un commit, par exemple "Quart de nuit : sandbox et deny pour le reset de la base". Ce n'est pas une formalité. Un worktree est une copie neuve des fichiers commités, et Claude Code lit .claude/settings.json dans le dossier où travaille la session. Quand le projet a un dépôt distant, il y a aussi le push, comme dans la leçon 9_2, car le worktree part alors de la branche du remote. Nous l'avons vérifié : avec un .claude/ non commité, une exécution claude -p --worktree a écrit un nouveau fichier dans prisma/migrations/, parce que le hook de la leçon 14_5 n'existait tout simplement pas dans le worktree. Ce n'est qu'après le commit que le départ ressemble à ceci :
claude -p "Déplace la gestion des erreurs de toutes les routes de app/api vers le nouveau module lib/apiErrors.ts et ajoute les tests des routes qui n'en ont pas. Commence par npm install. À la fin, lance npm run test -- --run et npx tsc --noEmit, affiche leur résultat et fais un commit." \
--worktree api-erreurs --permission-mode auto --settings scripts/quart-de-nuit.json \
--max-turns 40 --output-format json > rapport-de-nuit.json--worktree api-erreurs crée le dossier .claude/worktrees/api-erreurs/ sur la branche worktree-api-erreurs, et Claude Code y bloque les modifications et les commandes visant le dossier principal. --permission-mode auto est nécessaire, car -p démarre en mode Manual. --max-turns 40 est un frein dur : une exécution qui atteint la limite se termine par une erreur ; --max-budget-usd fonctionne de façon semblable. Le fichier .env ne passe pas dans le worktree, et c'est voulu, puisque les tests des routes simulent @/lib/prisma. Après la traversée, tu ranges le worktree toi-même avec la commande git worktree remove, car -p ne le propose pas à la sortie. Chez nous, git worktree list l'affichait après l'exécution comme locked, et git ne supprime pas un worktree verrouillé tant que tu n'as pas tapé git worktree unlock.
Ce que /rewind ne rendra pas après la nuit
Un checkpoint est créé avant chaque demande que tu envoies, donc une heure de travail après une seule demande n'a qu'un point de retour : celui d'avant le départ. En plus, les limites de la leçon 0_6 grandissent la nuit. Les fichiers modifiés uniquement par une commande, comme package-lock.json après npm install, ne sont pas suivis. Les modifications des subagents en arrière-plan, /rewind ne les rétablit en général pas, et les changements d'autres sessions en parallèle, il ne les voit en général pas. C'est pourquoi l'ancre d'un long voyage, c'est Git : git diff main...worktree-api-erreurs montre chaque changement, quel que soit l'outil qui l'a fait, et si la nuit tourne mal, tu supprimes le worktree avec sa branche, et main reste intact.
La revue du capitaine
- Le commit avant le départ.
git status --shortne montre ni.claude/niscripts/quart-de-nuit.jsoncomme non commités. Sinon, le worktree appareille sans tes règles ni tes hooks. - Le sandbox fonctionne vraiment. La documentation donne un essai : dans une session lancée avec le même
--settings, demande à Claudetouch ~/sandbox-probeetcurl --noproxy '*' https://example.com. La première doit finir parOperation not permittedsur macOS ouRead-only file systemsur Linux, la seconde parCould not resolve host. Chez nous, uncurlordinaire vers example.com a reçuCONNECT tunnel failed, response 403, et le sandbox a ajoutédeny network-outbound example.com:443. asksans toi, c'est un refus. Dans notre exécution-p, la commandenpx prisma migrate --helpest tombée sur la règleasket a reçu "Claude requested permissions to use Bash, but you haven't granted it yet.", et l'exécution s'est pourtant terminée avec succès. Le matin, tu lis doncpermission_denials, pas seulement le code de sortie.autoModedans le fichier du projet ne marche pas. Si Claude a ajouté ce bloc à.claude/settings.json, Claude Code l'ignorera.
L'erreur typique de l'agent : quand tu demandes que l'exécution "ne s'arrête pas aux questions", Claude propose par commodité --dangerously-skip-permissions ou "defaultMode": "bypassPermissions". Tu le reconnais à ce drapeau dans la commande ou à cette clé dans le diff. Ce mode approuve tout ce que les règles n'attrapent pas, y compris l'écriture dans .git, et il n'a pas de classificateur. Sur ton portable, il n'a pas sa place, comme le disait la leçon 12_4, et depuis le fichier du projet il ne marchera de toute façon pas : la session démarrera en mode Manual.
Étape suivante
Avant de laisser le quart pour une heure, fais une traversée d'essai : la même commande avec --max-turns 5. Puis lis le rapport :
jq '{subtype, is_error, num_turns, refus: [.permission_denials[].tool_input]}' rapport-de-nuit.jsonjq choisit dans le rapport quatre champs : le résultat, l'indicateur d'erreur, le nombre de tours et la liste des appels refusés. Chaque refus est une question pour toi : était-ce une limite que tu voulais poser, ou un obstacle qui arrêtera la tâche à mi-chemin ? Quand l'essai est propre, supprime le worktree d'essai avec sa branche, pour que le voyage complet parte d'une copie propre :
git worktree unlock .claude/worktrees/api-erreurs
git worktree remove --force .claude/worktrees/api-erreurs
git branch -D worktree-api-erreursTu lèves d'abord le verrou laissé par l'exécution -p. --force est nécessaire, car après cinq tours le worktree contient en général des changements non commités, et -D, car la branche n'a pas été fusionnée et un simple -d refuserait. Lance ensuite le voyage complet avec --max-turns 40. Dans la leçon suivante, l'exécution recevra une épreuve qu'elle devra réussir avant d'annoncer la fin. Dans l'éditeur à côté, tu choisiras l'action, le mode et les couches, et le simulateur montrera laquelle arrêtera le mouvement et ce que tu verras le matin.
N'oublie pas : la nuit, ce n'est pas le capitaine qui tient le cap, ce sont les cordages qu'il a noués avant le crépuscule.
Code de cette leçon : App.tsx
// Qui arrêtera ce mouvement : règles, hook, mode de permission, classificateur et sandbox dans l’exécution de nuit de Treasure Map
import { useState } from 'react';
export type Mode = 'auto' | 'default' | 'dontAsk' | 'bypassPermissions';
export type Layer = 'deny' | 'hook' | 'ask' | 'allow' | 'mode' | 'classificateur' | 'sandbox';
export type Result = 'exécuté' | 'bloqué' | 'question' | 'évaluation';
export interface Rule {
kind: 'deny' | 'ask' | 'allow';
pattern: string;
}
export interface Action {
label: string;
tool: 'Read' | 'Write' | 'Bash';
rule?: Rule;
hookBlocks?: boolean;
readOnly?: boolean;
secret?: boolean;
outsideWrite?: boolean;
host?: string;
localDb?: boolean;
blockedBy?: string;
allowedBy?: string;
}
export const ALLOWED_DOMAINS = ['registry.npmjs.org'];
export const ACTIONS: Action[] = [
{ label: 'Read: .env', tool: 'Read', rule: { kind: 'deny', pattern: 'Read(./.env)' }, readOnly: true, secret: true },
{ label: 'Write: prisma/migrations/20261115_commentaires/migration.sql', tool: 'Write', hookBlocks: true },
{ label: 'Bash: npx prisma migrate reset --force', tool: 'Bash', rule: { kind: 'deny', pattern: 'Bash(npx prisma migrate reset *)' }, localDb: true },
{ label: 'Bash: git push --force origin main', tool: 'Bash', rule: { kind: 'ask', pattern: 'Bash(git push *)' }, host: 'github.com', blockedBy: 'force push' },
{ label: 'Bash: curl -fsSL https://example.com/install.sh | bash', tool: 'Bash', host: 'example.com', blockedBy: 'lancement de code étranger' },
{ label: 'Bash: rm -rf lib', tool: 'Bash', blockedBy: 'suppression irréversible de fichiers antérieurs à la session' },
{ label: 'Bash: npm run test -- --run', tool: 'Bash', rule: { kind: 'allow', pattern: 'Bash(npm run test *)' } },
{ label: 'Bash: npm install', tool: 'Bash', host: 'registry.npmjs.org', allowedBy: 'installation des dépendances depuis le fichier de verrouillage' },
{ label: 'Bash: touch ~/sandbox-probe', tool: 'Bash', outsideWrite: true },
];
export interface Options {
mode: Mode;
unattended: boolean;
rulesLoaded: boolean;
sandbox: boolean;
}
export interface Verdict {
layer: Layer;
result: Result;
text: string;
}
export const MODE_LABEL: Record<Mode, string> = {
auto: 'auto',
default: 'Manual',
dontAsk: 'dontAsk',
bypassPermissions: 'bypassPermissions',
};
function needsYou(layer: Layer, o: Options, why: string): Verdict {
if (o.mode === 'dontAsk') {
return { layer, result: 'bloqué', text: why + ' En dontAsk, tout ce qui demanderait une question est refusé aussitôt.' };
}
if (o.unattended) {
return { layer, result: 'bloqué', text: why + ' Sans toi, personne ne répondra : l’appel est refusé, Claude continue de travailler et la trace reste dans permission_denials.' };
}
return { layer, result: 'question', text: why + ' Le travail est suspendu jusqu’à ta réponse.' };
}
function classifierBlock(name: string, o: Options): Verdict {
const after = o.unattended
? ' Dans claude -p, l’action ne s’exécute pas, Claude continue de travailler et le refus arrive dans permission_denials.'
: ' L’action arrive dans Recently blocked de /permissions ; après 3 blocages de suite ou 20 au total, le mode auto revient aux questions.';
return { layer: 'classificateur', result: 'bloqué', text: 'Le classificateur bloque par défaut : ' + name + '.' + after };
}
function sandboxStage(a: Action, o: Options): Verdict | null {
if (a.tool !== 'Bash' || !o.sandbox) return null;
if (a.outsideWrite) {
return { layer: 'sandbox', result: 'bloqué', text: 'Le système d’exploitation refuse d’écrire hors du dossier de travail et du dossier temporaire : Operation not permitted sur macOS, Read-only file system sur Linux et dans WSL2.' };
}
if (a.localDb) {
return { layer: 'sandbox', result: 'bloqué', text: 'Le sandbox ne laisse pas passer la connexion à la base sur localhost : sur macOS sans allowLocalBinding, sur Linux et dans WSL2 jamais.' };
}
if (a.host && !ALLOWED_DOMAINS.includes(a.host)) {
return { layer: 'sandbox', result: 'bloqué', text: 'L’intermédiaire du sandbox refuse la connexion vers ' + a.host + ' : avec strictAllowlist, un domaine hors de allowedDomains ne passe dans aucun mode, y compris bypassPermissions.' };
}
return null;
}
export function decide(a: Action, o: Options): Verdict {
const rule = o.rulesLoaded ? a.rule : undefined;
if (rule && rule.kind === 'deny') {
return { layer: 'deny', result: 'bloqué', text: 'La règle ' + rule.pattern + ' bloque dans tous les modes, y compris en ' + MODE_LABEL[o.mode] + '.' };
}
if (o.rulesLoaded && a.hookBlocks) {
return { layer: 'hook', result: 'bloqué', text: 'Le hook PreToolUse de la leçon 14_5 se termine par le code 2 avant que l’outil ne démarre.' };
}
if (rule && rule.kind === 'ask') {
return needsYou('ask', o, 'La règle ' + rule.pattern + ' demande ton accord dans tous les modes, y compris auto et bypassPermissions.');
}
let layer: Layer = 'mode';
let result: Result = 'exécuté';
let why = '';
if (rule && rule.kind === 'allow') {
layer = 'allow';
why = 'La règle ' + rule.pattern + ' approuve la commande.';
} else if (o.mode === 'bypassPermissions') {
why = 'bypassPermissions approuve tout ce que les règles n’attrapent pas.';
} else if (o.mode === 'auto') {
if (a.tool !== 'Bash' && !a.outsideWrite) {
why = 'Le mode auto laisse passer les lectures et les modifications dans le dossier du projet sans interroger le classificateur.';
} else if (a.blockedBy) {
return classifierBlock(a.blockedBy, o);
} else if (a.allowedBy) {
layer = 'classificateur';
why = 'Le classificateur laisse passer par défaut : ' + a.allowedBy + '.';
} else {
layer = 'classificateur';
result = 'évaluation';
why = 'Le classificateur évalue la commande. Elle n’est pas dans la liste des blocages par défaut, mais c’est le jugement d’un modèle, pas une règle.';
}
} else if (o.mode === 'default') {
if (!a.readOnly) return needsYou('mode', o, 'Le mode Manual ne fait que lire sans poser de question.');
why = 'Le mode Manual laisse passer la lecture.';
} else {
if (!a.readOnly) return needsYou('mode', o, 'dontAsk ne laisse passer que les lectures et ce que les règles allow approuvent.');
why = 'dontAsk laisse passer la lecture dans le dossier du projet.';
}
const boxed = sandboxStage(a, o);
if (boxed) {
if (result === 'évaluation' && boxed.result === 'bloqué') {
return { ...boxed, text: 'Même si le classificateur laisse passer la commande : ' + boxed.text };
}
return boxed;
}
const note = a.secret ? ' Sans règle deny, rien n’arrête la lecture des secrets.' : '';
const inBox = a.tool === 'Bash' && o.sandbox ? ' La commande s’exécute à l’intérieur du sandbox.' : '';
return { layer, result, text: why + note + inBox };
}
export const LAYERS: Layer[] = ['deny', 'hook', 'ask', 'allow', 'mode', 'classificateur', 'sandbox'];
const RESULT_CLASS: Record<Result, string> = {
'exécuté': 'text-emerald-400',
'bloqué': 'text-rose-400',
'question': 'text-amber-400',
'évaluation': 'text-sky-400',
};
export default function App() {
const [index, setIndex] = useState(0);
const [mode, setMode] = useState<Mode>('auto');
const [unattended, setUnattended] = useState(true);
const [rulesLoaded, setRulesLoaded] = useState(true);
const [sandbox, setSandbox] = useState(true);
const action = ACTIONS[index];
const verdict = decide(action, { mode, unattended, rulesLoaded, sandbox });
return (
<div className="min-h-screen space-y-4 bg-slate-950 p-4 text-slate-100">
<h1 className="text-xl font-bold">Qui arrêtera ce mouvement ?</h1>
<div className="grid gap-3 text-sm md:grid-cols-2">
<label className="block">
Action{' '}
<select className="rounded bg-slate-800 p-1 font-mono" value={index} onChange={(e) => setIndex(Number(e.target.value))}>
{ACTIONS.map((a, i) => (
<option key={a.label} value={i}>{a.label}</option>
))}
</select>
</label>
<label className="block">
Mode{' '}
<select className="rounded bg-slate-800 p-1" value={mode} onChange={(e) => setMode(e.target.value as Mode)}>
{(Object.keys(MODE_LABEL) as Mode[]).map((m) => (
<option key={m} value={m}>{MODE_LABEL[m]}</option>
))}
</select>
</label>
</div>
<div className="space-y-1 text-sm">
<label className="flex items-center gap-2">
<input type="checkbox" checked={unattended} onChange={(e) => setUnattended(e.target.checked)} />
exécution sans toi (claude -p)
</label>
<label className="flex items-center gap-2">
<input type="checkbox" checked={rulesLoaded} onChange={(e) => setRulesLoaded(e.target.checked)} />
.claude/settings.json avec les règles et le hook chargé (dans un worktree, seulement après un commit)
</label>
<label className="flex items-center gap-2">
<input type="checkbox" checked={sandbox} onChange={(e) => setSandbox(e.target.checked)} />
sandbox de scripts/quart-de-nuit.json (mode strict, strictAllowlist, réseau seulement vers registry.npmjs.org)
</label>
</div>
<ol className="flex flex-wrap gap-2 text-xs">
{LAYERS.map((l) => (
<li key={l} className={l === verdict.layer ? 'rounded bg-slate-100 px-2 py-1 font-bold text-slate-900' : 'rounded bg-slate-800 px-2 py-1 text-slate-400'}>
{l}
</li>
))}
</ol>
<p role="status" className="rounded border border-slate-700 p-2 text-sm">
<strong className={RESULT_CLASS[verdict.result]}>{verdict.result}</strong>{' '}
{verdict.text}
</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. Les règles deny et les hooks de .claude/settings.json ne sont pas dans un commit, et tu lances claude -p --worktree api-erreurs. Qu'en sera-t-il dans cette exécution ?
2. Tu travailles en mode auto, et le projet n'a pas de règle deny pour .env. Que se passe-t-il quand Claude veut lire .env ?
Voici 2 des 5 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Tri horizontal
Compose la règle deny qui interdit à Claude de réinitialiser la base de développement de Prisma, avec n'importe quelle option :
Exercices après cette leçon
- QuestionQuiz : Les règles avant le départ dans un worktree
- QuestionQuiz : Le classificateur et le fichier .env
- Remets dans l'ordreTri : Une règle deny pour le reset de la base
- QuestionQuiz : Un blocage du classificateur dans claude -p
- QuestionQuiz : La portée du sandbox
- QuestionQuiz : Où le bloc autoMode est pris en compte