Mes 15 minutes de corvée chaque matin, j'ai tout refilé à une IA

Chaque matin, avant même de me faire un café, je répétais les mêmes gestes.

Ouvrir un dossier, vérifier les logs de la veille, regarder à l’œil si un test ne plantait pas, coller les diffs qui m’intriguaient dans un bloc-notes. Une minute par geste. Mais bout à bout, c’était fini quand le café avait refroidi. Tous les jours. Sauf le week-end, sans relâche.

Un matin, l’évidence m’a frappé : « Est-ce vraiment à moi de faire ça ? »

Réponse directe : non. Aujourd’hui, cette routine, c’est un petit script qui la termine pendant que je me passe de l’eau sur le visage. Et plus soigneusement que moi. Voici l’histoire, avec tout le code sous les yeux.

L’« automatisation », ce n’est pas réservé aux développeurs

Quand on entend automatisation, on imagine de la CI/CD, des pipelines de déploiement, des trucs intimidants. Moi, je parle de bien plus modeste.

Ces copier-coller que vous faites chaque jour, machinalement. Voilà ce qu’on fait porter par la machine.

Par exemple : récupérer des chiffres dans plusieurs fichiers pour les rassembler dans un tableau. Mettre des notes au propre dans un format défini. Comparer ce qui a changé entre hier et aujourd’hui. Repérer les notes périmées. À chaque fois, c’est plus « bouger les yeux et les doigts » que « réfléchir ». Un humain s’y trompe, s’en lasse, et surtout y voit son temps fondre.

C’est là qu’une IA, concrètement Claude Code, fait mouche. Une seule règle. Ne pas tout balancer à l’IA en vrac. « Fais au mieux » est l’accident assuré (je le prouverai plus loin avec mes ratés). À la place, on décide à l’avance ce qu’elle lit, ce qu’elle fait, ce à quoi elle n’a pas le droit de toucher, et on ne lui confie que la partie répétitive. Rien que ça, et le monde change.

Au passage, ce mot qui revient souvent ici : « harness » (harnais). Traduit littéralement c’est le harnachement d’un cheval, mais en pratique c’est le cadre extérieur qui empêche l’IA de partir en vrille. Que lui donne-t-on en entrée, jusqu’où l’autorise-t-on, comment garde-t-on une trace, comment l’arrête-t-on quand ça dérape. Retenez juste : on fabrique ce cadre d’abord.

Jusqu’où déléguer, à partir d’où regarder soi-même

Avant de déléguer, on trace une ligne, une seule fois. Sauter cette étape donne l’illusion de la vitesse, mais on le paie cher plus tard. Ma recommandation : quatre niveaux.

Niveau	Ce que je confie à l’IA	Ce que je garde pour moi
Enquête	Résumer logs, diffs, contenu des fichiers	L’importance et l’ordre des priorités
Mise en forme	Uniformiser le format, regrouper en tableau, faire un brouillon	Le jugement sur le fond et le feu vert final
Contrôle	Signaler tests qui plantent, notes vieillottes, diffs bizarres	Lesquelles de ces remarques retenir
Exécution	Génération et copie purement mécaniques	Les boutons supprimer, envoyer, publier

Le tracé est simple. Ce qui se rattrape, on le délègue. Ce qui ne se rattrape pas, on l’appuie avec son propre doigt. Supprimer, envoyer, facturer, publier. Ces quatre-là, au départ, sont tous sur « demander à un humain d’abord ». On ne promeut en automatique que ce qu’on a vu être sûr. Dans l’autre sens, on pleure.

Cette façon de tracer la ligne, je l’ai creusée davantage dans comment construire validation et sandbox ; à lire en complément, ça aide à digérer l’idée.

On le fait tourner : déléguer la vérification du matin

Assez de blabla, passons au concret. Mon « regarder les logs et les tests, et noter ce à quoi faire attention aujourd’hui » du matin, je le transforme tel quel en script. Il vous faut Node.js et une clé API Anthropic.

À enregistrer sous scripts/morning-check.mjs. Les commentaires sont tous en français.

#!/usr/bin/env node
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
import { join } from "node:path";

const logDir = ".claude-logs";
const lockFile = join(logDir, "morning.lock"); // la clé qui empêche un double lancement
const stamp = new Date().toISOString().replace(/[:.]/g, "-");
const logFile = join(logDir, `morning-${stamp}.log`);

function fail(message) {
  console.error(message);
  process.exit(1);
}

// petit assistant : lance une commande et récupère sa sortie telle quelle
function run(command, args, options = {}) {
  const result = spawnSync(command, args, {
    encoding: "utf8",
    shell: process.platform === "win32", // la formule magique pour que ça tourne aussi sous Windows
    ...options,
  });
  const output = `${result.stdout || ""}${result.stderr || ""}`;
  if (result.status !== 0) {
    writeFileSync(logFile, output);
    fail(`Commande en échec : ${command} ${args.join(" ")} / détails dans ${logFile}`);
  }
  return output;
}

// si on a oublié de mettre la clé, on s'arrête sans rien faire (important, ça)
if (!process.env.ANTHROPIC_API_KEY) {
  fail("Définissez d'abord ANTHROPIC_API_KEY.");
}

mkdirSync(logDir, { recursive: true });
if (existsSync(lockFile)) {
  fail(`La vérification précédente tourne encore : ${lockFile}`);
}
writeFileSync(lockFile, String(process.pid));

try {
  // 1. on rassemble l'état actuel (ici, pas d'IA, juste des commandes)
  const status = run("git", ["status", "--short"]);
  const tests = run("npm", ["test"]);

  // 2. on passe la matière à l'IA pour qu'elle liste seulement les points à surveiller aujourd'hui
  const prompt = [
    "Tu es mon préposé à la vérification du matin.",
    "Lis le git status et le résultat des tests ci-dessous, puis liste en puces les points à surveiller aujourd'hui.",
    "Tu ne modifies, ne supprimes, ne commit, n'envoies rien. Tu lis, c'est tout.",
    "Classe par : authentification / double exécution / retour arrière / logs / décision humaine requise.",
    "",
    "git status :",
    status || "(aucun changement)",
    "",
    "sortie des tests (la fin seulement) :",
    tests.slice(-12000), // on ne passe pas tout le log. La fin suffit
  ].join("\n");

  const report = run("claude", [
    "-p", prompt,
    "--max-turns", "5",
    "--permission-mode", "plan", // mode lecture seule. On ne le laisse rien réécrire
    "--output-format", "text",
  ]);

  writeFileSync(logFile, report);
  console.log(`Note de vérification du jour écrite → ${logFile}`);
} finally {
  rmSync(lockFile, { force: true }); // une fois fini, on retire toujours la clé
}

Pour lancer, c’est tout.

node scripts/morning-check.mjs

Quelques dizaines de lignes, et pourtant on y trouve déjà « rassembler la matière », « passer à l’IA », « restreindre à la lecture seule », « empêcher un double lancement par une clé », « sauvegarder le log ». Voilà le squelette de l’automatisation. Si votre routine matinale est différente, il suffit de remplacer les parties git status et npm test par les commandes que vous tapez d’habitude. Je l’ai écrit pour que ça tourne même sans tout comprendre, mais une fois à l’aise, mettez-y les mains.

Là où ça change tout (trois cas)

1. Rassembler des fichiers éparpillés en une seule feuille Sept CSV de factures dispersés dans un dossier. Chaque mois, je les ouvrais à la main pour en sortir le total. Coller un par un dans Excel, additionner, revérifier. Une vingtaine de minutes. Et le mois dernier, à cause d’une faute de copie, j’ai rapporté un chiffre décalé d’un rang ; rouge de honte après coup. Aujourd’hui, « lis tous les CSV de ce dossier et fais-moi un tableau du total et seulement des lignes très écartées de la moyenne », et c’est plié. Un humain à la calculette décale d’un rang ; la machine, non. La revérification a disparu avec.

2. Aligner les diffs d’hier et d’aujourd’hui Quand on veut juste savoir « ce qui a changé » dans un fichier de config ou des notes par rapport à la sauvegarde de la veille. Comparer tout le texte de haut en bas, c’est l’enfer : les yeux glissent. Alors je fais extraire seulement les diffs, et je juge moi-même « est-ce un vrai changement, ou juste une faute de frappe ». On ne laisse pas le jugement à l’IA, on ne lui confie que le travail de repérage. Trois minutes à l’œil sont passées à cinq secondes.

3. Mettre des notes en vrac dans un format défini Les notes griffonnées en pleine réunion. Dates dans tous les sens, pas de titres, fautes partout, des flèches qui ne veulent plus rien dire. On demande : « mets en forme selon le modèle décidé, mais sans rien ajouter au contenu. » Ici, l’important, c’est de ne pas lui faire écrire à partir de rien, mais juste mettre en forme. Dites « résume au mieux » et l’IA comble toute seule avec des choses que vous n’avez jamais dites. On précise : la forme, et rien d’autre. Rien que ça, et on ne se fait plus enjoliver la réalité.

Mes trois plantages personnels

Sans frime. Mes premières automatisations furent une suite d’accidents.

Le premier. J’ai tout balancé en vrac avec « range au mieux ». Résultat, l’IA a « rangé » jusqu’aux fichiers de config qu’il ne fallait surtout pas effacer. Le code qui tournait était resté, mais ce matin-là j’ai vraiment blêmi. Le .env avait disparu, le service ne démarrait plus, une heure pour tout remettre. Depuis, je précise toujours d’abord le périmètre autorisé : « seulement dans ce dossier », « ne touche pas à ce fichier ». Il ne faut pas compter sur l’IA pour deviner.

Le deuxième. J’ai fourré tout le log dans le prompt. Par gentillesse, je lui passais des dizaines de milliers de lignes ; la ligne d’échec qui comptait était noyée, et l’IA pointait « le problème est là » à un endroit totalement faux. Seuls la facture et le temps gonflaient, et je finissais par tout relire moi-même. Aujourd’hui, comme dans le code ci-dessus, je passe seulement la fin avec slice(-12000). Les erreurs sortent à la fin. L’IA lit le mieux les dernières lignes. Donc la fin suffit.

Le troisième. J’ai lancé le même script en double. Une erreur de config dans le planificateur de tâches, et la vérification du matin a démarré deux fois, presque en même temps. Le log s’écrasait, impossible de savoir lequel était le bon. Le pire, c’est quand c’est une tâche « qui écrit ». On génère deux fois la même note, et on efface ensuite les doublons à la main. Depuis que j’ai ajouté un fichier de verrou (la clé), le second arrivé se fait recaler d’un « la précédente tourne encore » et le problème se règle d’un coup. Un dispositif de trois lignes à peine, mais sans lui, on se fait avoir pile les matins chargés.

Par où commencer

Ne visez surtout pas le tout-automatique d’emblée. Choisissez une petite tâche, une seule, où l’échec ne fait pas pleurer. La vérification du matin, le total de fichiers, la mise en forme de notes. C’est exactement le bon calibre.

La marche à suivre est toujours la même. ① Restreindre étroitement ce qu’on lui donne à lire → ② Mettre en mots clairs l’objectif (le résultat fini) → ③ Confier les vérifications à des commandes autant que possible → ④ Fixer supprimer, envoyer, facturer, publier sur « demander à un humain ». Seules les opérations qu’on a vues sûres montent ensuite en automatique. Rien qu’en respectant cet ordre, les accidents s’effondrent.

Quand vous voudrez le lancer chaque jour à heure fixe, inscrivez-le dans cron ou le planificateur de tâches.

# Linux/macOS : exécution à 8 h 15 les jours ouvrés
15 8 * * 1-5 cd /path/to/repo && /usr/bin/node scripts/morning-check.mjs >> .claude-logs/cron.log 2>&1

# Windows : inscrire une tâche quotidienne à 8 h 15 dans le planificateur
schtasks /Create /TN "MorningCheck" /SC DAILY /ST 08:15 /F /TR "powershell -NoProfile -ExecutionPolicy Bypass -Command \"cd C:\path\to\repo; node scripts\morning-check.mjs\""

Quoi regarder quand ça s’arrête, le sens d’arguments fins comme --permission-mode : la référence officielle de la CLI est la source de référence. En cas de pépin, commencez par là, ça évite les détours. Si vous trébuchez dès le premier pas, picorez aussi dans Claude Code, les 30 premières minutes.

Ce que j’ai testé, concrètement

Pour être honnête, la première semaine, le script m’a pris plus de temps que de tout faire à la main. La clé oubliée et ça plante, trop de logs et la réponse part de travers, le planificateur qui ne démarre même pas. J’ai tout corrigé à la main.

Mais à partir de la deuxième semaine, ça a payé. Aujourd’hui, le matin, quand je reviens à mon bureau après m’être lavé le visage, .claude-logs aligne seulement trois à cinq lignes des points à surveiller. Du genre : « tests au vert, mais cette dépendance est vieille », ou « un fichier que je ne me souviens pas avoir supprimé apparaît dans le diff, à vérifier ».

Ce qui m’a le plus réjoui, c’est que la « flemme » du matin a disparu. Plus de temps passé à répéter les mêmes gestes par inertie ; je reverse ce temps dans le travail qui demande vraiment de réfléchir. Plutôt que de chercher l’IA la plus intelligente, je refile à la machine, une par une, mes petites corvées de cinq minutes. C’est modeste, mais c’est ce qui a le mieux marché.

En résumé

L’automatisation, ce n’est pas du déploiement ni des grands mots. C’est faire porter par la machine les copier-coller que vous faites chaque jour, machinalement. Rien de plus.

Trois astuces. Restreindre étroitement ce qu’on lui donne à lire. Mettre en mots le résultat fini. N’appuyer qu’avec son propre doigt les opérations qui ne se rattrapent pas. Commencez par faire tourner le script ci-dessus, adapté à votre travail, et retranchez dès demain matin une de vos cinq minutes.

Si vous voulez apprendre de façon plus structurée, ou automatiser d’un coup le travail de votre équipe, j’ai réuni de quoi apprendre en pratiquant dans la liste des supports. Et si vous voulez en parler pour votre cas, faites-moi signe depuis là.