Aller au contenu principal
J'ai corrigé 120 livres avec l'IA — 65 000 corrections en 8 passes
Retour au blog
Écriture

J'ai corrigé 120 livres avec l'IA — 65 000 corrections en 8 passes

Patrice Huetz28 mars 202613 min

« Projetait » ou « projétait » ? « Il à raison » ou « il a raison » ? « Les oubliés du système, qui avaient été abandonné » — abandonné ou abandonnés ?

Quand tu écris un roman, tu ne penses pas à l'orthographe. Tu penses aux personnages, à l'intrigue, au rythme. Et quand tu en écris 120 — 14 sagas, 4 835 chapitres, environ 4 millions de mots — les fautes s'accumulent. Par dizaines de milliers.

Un correcteur professionnel facture 2-3 € par page. Pour 120 livres, c'est un budget de 30 000 €. Les correcteurs automatiques classiques ne comprennent pas le contexte : ils ne voient pas la différence entre « il à » (faux) et « il a » (vrai), entre « du » (article) et « dû » (participe passé). Et relire manuellement 4 835 chapitres, c'est des semaines de travail à temps plein.

J'ai choisi une autre voie : 20 agents IA en parallèle, 8 passes de correction, et des scripts Grep/sed pour les patterns récurrents. Voici le récit de cette opération massive.

L'état des lieux : un désastre discret

Tout a commencé quand j'ai voulu publier mes premiers tomes sur Amazon KDP. J'ai ouvert un fichier au hasard — tome 4 des Oubliés — et j'ai compris l'ampleur du problème.

Ces tomes avaient été générés sans accents français. Pas « manqués ici et là ». Zéro accent. « Etait » au lieu de « était ». « A » au lieu de « à ». « Premiere » au lieu de « première ». Sur des chapitres de 4 000 mots, ça faisait parfois 200 corrections par chapitre.

⚠️
Les Oubliés tomes 4 et 5 ont nécessité à eux seuls 6 passes dédiées. Les tomes générés entièrement sans accents sont un cas extrême — mais même les tomes « normaux » avaient 20-50 fautes par chapitre. Sur 4 835 chapitres, ça fait entre 97 000 et 240 000 fautes potentielles.

Mais les accents n'étaient que la partie visible. En creusant, j'ai trouvé des problèmes à tous les niveaux :

  • Accords de participes passés : « Les soldats qui avaient été envoyé » (envoyés)
  • Confusion à/a, ou/où, du/dû : les classiques de la langue française, multipliés par 4 millions de mots
  • Typographie française : guillemets droits au lieu de « chevrons », absence d'espaces insécables devant les ponctuations doubles
  • Incohérences de style : mélange de passé simple et passé composé dans un même chapitre
  • Noms propres : un personnage qui s'appelle « Dmitri » dans un chapitre et « Dimitri » dans le suivant

L'architecture : agents parallèles et passes successives

La solution que j'ai mise en place repose sur trois piliers : Claude Code pour l'intelligence linguistique, Grep pour la détection de patterns à grande échelle, et sed pour les corrections batch quand le pattern est sans ambiguïté.

Le principe des passes

Chaque passe cible un type de faute spécifique. On ne mélange pas tout dans une seule passe — c'est la leçon numéro un. Un agent qui corrige les accents ET la grammaire ET la ponctuation en même temps finit par faire des corrections contradictoires.

PasseCibleMéthodeNb corrections
1-3Accents manquants (à, é, è, ê, î, ô, û)Grep + sed + validation IA~25 000
4-5Grammaire et accords (participes, sujet-verbe)Agents Claude Code~18 000
6-7Ponctuation et typographie françaisesed (guillemets, espaces insécables)~15 000
8Scan exhaustif (70+ patterns de fautes)Agents Claude Code~7 000
Total~65 000

La parallélisation

Pour chaque passe, je lançais 9 à 20 agents Claude Code en parallèle, chacun responsable d'un groupe de livres. Avec Claude Code, tu peux ouvrir 20 terminaux et lancer 20 sessions simultanées — chaque agent travaille sur son sous-ensemble de fichiers sans interférer avec les autres.

bash
# Exemple de lancement parallèle — passe 4 (grammaire)
for saga in Oublies Conquerants Architectes Ombres Sang; do
  claude --print < "prompts/correction-grammaire.md" \
    --arg "dir=Les_${saga}/" &
done
wait
💡
La clé de la parallélisation, c'est le découpage par saga/projet. Chaque agent travaille sur un répertoire isolé. Pas de conflits git, pas de fichiers verrouillés. Et si un agent plante, les 19 autres continuent. J'ai rarement perdu plus de 2-3 minutes de travail sur une panne.

Les passes en détail

Passes 1-3 : la guerre des accents

Les trois premières passes sont les plus « mécaniques ». On utilise Grep pour identifier tous les mots sans accent qui devraient en avoir :

bash
# Trouver tous les "etait" qui devraient être "était"
grep -rn "\betait\b" Les_Oublies/ --include="*.md"
# Résultat : 4 327 occurrences

# Correction batch (pattern sans ambiguïté)
sed -i 's/\betait\b/était/g' Les_Oublies/**/*.md

Mais attention : tous les patterns ne sont pas sans ambiguïté. « Du » peut être l'article (« du pain ») ou le participe passé de « devoir » (« j'aurais dû »). Pour ces cas, on passe par un agent Claude Code qui analyse le contexte de chaque occurrence.

ℹ️
Les 3 premières passes ont trouvé ~25 000 corrections, soit 38 % du total. C'est la loi de Pareto des corrections : les patterns simples (accents manquants, fautes systématiques) représentent la majorité du volume et sont les plus faciles à corriger. Les 5 passes suivantes cherchent les 62 % restants — et c'est là que ça devient compliqué.

Passes 4-5 : la grammaire contextuelle

Les accords de participes passés sont le cauchemar de la correction automatique. « Les soldats qui avaient été envoyé » — le correcteur doit comprendre que « envoyé » se rapporte à « soldats » (masculin pluriel → envoyés), pas à un sujet singulier.

Pour ces passes, chaque agent Claude Code reçoit un prompt spécialisé :

markdown
Tu es un correcteur orthographique et grammatical expert en français.

Pour chaque fichier markdown :
1. Lis le fichier intégralement
2. Identifie les fautes de grammaire (accords, conjugaisons, concordance des temps)
3. Corrige directement dans le fichier
4. Ne touche PAS au style, au vocabulaire, ni à la structure narrative
5. Log chaque correction dans un commentaire en fin de fichier

ATTENTION : ne modifie que les fautes avérées. En cas de doute, ne corrige pas.

Le « en cas de doute, ne corrige pas » est crucial. Un agent trop agressif crée des faux positifs — et corriger les corrections est plus pénible que corriger les fautes originales.

Passes 6-7 : la typographie française

La typographie française a des règles strictes : guillemets « chevrons » au lieu de guillemets droits "comme ça", espace insécable avant les ponctuations doubles (: ; ! ?), tirets cadratins pour les dialogues.

Ces passes sont majoritairement automatisables avec sed :

bash
# Remplacer les guillemets droits par des chevrons
sed -i 's/"/« /g; s/"/ »/g' **/*.md

# Ajouter les espaces insécables (avec espace fine insécable Unicode)
sed -i 's/ :/\xC2\xA0:/g; s/ ;/\xC2\xA0;/g' **/*.md

Passe 8 : le scan final

La dernière passe est la plus ambitieuse : un scan exhaustif avec 70+ patterns de fautes compilés au fil des 7 passes précédentes. Chaque pattern représente une faute récurrente découverte pendant les passes précédentes :

  • « malgré que » → « bien que » (barbarisme)
  • « au jour d'aujourd'hui » → « aujourd'hui » (pléonasme)
  • « il sembla que + indicatif » → « il sembla que + subjonctif »
  • Doubles espaces, lignes vides en excès, tirets inconsistants

Les pièges et les bugs

L'opération n'a pas été sans incidents. Voici les trois pièges les plus mémorables.

Le faux positif « projétait »

Un sed trop enthousiaste sur le pattern « e → é » a transformé « projetait » en « projétait ». Ce mot n'existe pas. Mais comme le pattern était appliqué en batch sur 120 livres, la correction erronée est apparue dans 47 fichiers. Il a fallu reverter, affiner le regex, et relancer.

⚠️
Règle d'or des corrections batch : toujours faire un `git diff` avant de commiter. Et toujours travailler sur une branche dédiée. Le revert d'un sed raté sur 4 835 fichiers n'est pas une expérience que tu veux vivre sans git.

La guerre des guillemets

Les guillemets français « » et les guillemets droits "" coexistaient dans certains tomes. Le sed de remplacement transformait parfois des guillemets anglais dans du code (exemples techniques) en guillemets français — cassant la syntaxe. Solution : exclure les blocs de code markdown (entre ```) du remplacement.

L'agent qui corrige le style

Malgré le prompt explicite « ne touche PAS au style », un agent a décidé qu'un passage en argot dans un dialogue de mafieux était une « faute de registre » et l'a corrigé en français soutenu. Un capo de la mafia marseillaise qui dit « Je vous serais gré de bien vouloir cesser » au lieu de « Ferme-la ou je te descends » — ça casse un peu l'immersion. Heureusement, le diff l'a trahi.

Ce que j'ai appris

L'IA est excellente pour la correction à grande échelle, mais elle nécessite une supervision humaine. Les 3 premières passes trouvent 90 % des erreurs. Les 5 suivantes trouvent les 10 % restants — et c'est là que c'est le plus difficile, parce que les cas ambigus demandent du jugement.

La parallélisation est la clé. Sans les 20 agents en parallèle, l'opération aurait pris des jours. Avec, c'est une question d'heures — plus le temps de review entre les passes.

Les corrections batch (sed) sont puissantes mais dangereuses. Toujours tester sur un échantillon. Toujours vérifier le diff. Toujours travailler avec git.

La structure en passes est non négociable. Un agent qui corrige tout en une fois fait plus de dégâts qu'un agent spécialisé. La spécialisation réduit les faux positifs.

Cette opération de correction massive illustre un point central de mes livres : l'IA ne remplace pas l'humain — elle amplifie ses capacités. Un humain seul ne peut pas corriger 4 835 chapitres. Mais un humain qui orchestre 20 agents IA, qui conçoit les passes, qui vérifie les diffs — celui-là peut faire en quelques heures ce qui prenait des semaines.

Si tu veux comprendre comment orchestrer des agents IA à cette échelle — le Ralph Loop, les subagents, le parallélisme — j'ai un livre pour ça.

La Boucle Ralph
La Boucle Ralph

Guide Pratique du Coding Autonome par IA.

Découvrir →

Et si tu veux construire toi-même des agents LLM en Python — avec la mémoire, les outils, la sécurité — voici le guide complet.

Agents LLM en Python
Agents LLM en Python

Des agents qui marchent. En Python.

Découvrir →
🔒

Soutenez mon travail sur Patreon

Accès anticipé aux articles, contenu exclusif, et la satisfaction de soutenir un auteur indépendant.

Rejoindre — à partir de 3€/mois

Commentaires

Chargement des commentaires...

Laisser un commentaire