Numériser les modes opératoires d'atelier (métallurgie, usinage) avec l'IA générative

Devant le tour, un jeune embauché depuis trois ans tenait son téléphone, immobile. Dans la marge du plan, le chef d’équipe précédent avait écrit au crayon : « ici, beaucoup d’huile », « chanfrein autour de 0,3, à surveiller ». Le sens, il le comprenait. Mais le pourquoi, non. Et le chef d’équipe était parti en retraite le mois dernier.

Quand j’ai commencé à aider de petits ateliers de mécanique sur l’amélioration de leur atelier, c’est la demande qui revenait le plus souvent : « le réglage n’existe que dans la tête d’une personne ». Des modes opératoires, il y en a, oui. Mais ils ont été tapés il y a dix ans sur un vieux traitement de texte, et plus personne ne sait où sont les fichiers. Au final, l’atelier tourne au papier et à la mémoire des anciens.

Chaque fois qu’un ancien part, c’est un réglage de plus qui disparaît de l’atelier. Ce n’est pas un problème de motivation. C’est un problème d’archivage. Aujourd’hui, je raconte comment mettre noir sur blanc ce « réglage dans la tête » et ces « notes dans la marge des plans », avec Claude Code et l’IA générative, dans la limite de ce que j’ai testé sur le terrain.

Points clés

• Si les modes opératoires ne se font jamais, ce n’est pas faute de temps pour écrire, mais parce que « transformer ce qu’on a dit en texte propre » est une corvée. C’est cette corvée qu’on confie à l’IA générative.
• Enregistrer un ancien pendant son travail, puis transcrire et laisser Claude Code mettre en forme un modèle de mode opératoire : c’est le flux qui coince le moins sur le terrain.
• Les notes dans la marge d’un plan se sauvent en trois étapes : photographier, transcrire, puis demander « pourquoi on fait ça » et l’ajouter.
• On confie à l’IA la mise en forme, le brouillon et le repérage des oublis. Les cotes, les tolérances et la sécurité sont toujours validées par un humain.
• Les plans et les noms de clients ne sortent pas de l’atelier. Si on rate ce point, c’est la confiance des clients qu’on perd.

D’abord, ce qui se passe vraiment dans un petit atelier

Le lecteur que j’imagine ici, c’est le chef d’atelier ou le responsable de production d’une PME de cinq à cinquante personnes. Usinage de métaux, emboutissage, plasturgie, montage, peu importe. Le point commun : Figma et le cloud sont à des années-lumière, et l’atelier tourne au tableur, au papier et au fax.

Voici un flux de travail typique :

1. Le client envoie un plan (en PDF, parfois sur papier).
2. Un ancien regarde le plan et décide du réglage (matière, montage, ordre d’usinage, points de vigilance).
3. Il transmet ce réglage à l’atelier, à l’oral ou par une note manuscrite.
4. On usine. Si un problème apparaît, l’ancien accourt.
5. C’est terminé. Quand la même référence revient, quelqu’un refait le réglage de mémoire.

Le problème, ce sont les étapes 3 et 5. Le réglage s’évapore dans « l’échange du moment ». Alors, six mois plus tard, on recommence à se souvenir de zéro. Ou bien la personne capable de s’en souvenir n’est plus là.

Les retours en arrière et les soucis fréquents

Voici des soucis concrets que j’entends souvent dans les ateliers :

• « On l’a déjà faite, cette référence, non ? » — et personne n’a noté la procédure.
• Les notes en marge du plan sont écrites d’une main si fine que seul l’auteur les déchiffre.
• À chaque nouvelle recrue, on réexplique la même chose, à l’oral.
• Quand un ancien est absent, la production s’arrête sur un réglage que lui seul connaît.
• Le client demande « c’étaient quoi, vos conditions d’usinage ? » et personne ne sait répondre.

Tout cela se résume à un seul point : il n’y a pas de trace écrite. Et s’il n’y en a pas, ce n’est pas par paresse. C’est qu’avec les mains pleines de graisse, on n’a pas le temps de rédiger un texte le jour même. On commence par reconnaître ça honnêtement.

Ce qu’on confie à l’IA, et ce qu’un humain décide toujours

Posons la limite d’entrée. Si on la laisse floue, on finit par sortir tel quel à l’atelier un mode opératoire écrit par l’IA, et on provoque un incident. C’est le pire scénario.

Étape	Confié à l’IA	Décidé par un humain
Recueil de la parole	Transcription, extraction des points clés	Quoi enregistrer, qui fait parler
Rédaction du mode opératoire	Brouillon, structure, repérage des oublis	Exactitude des cotes, tolérances, conditions
Mise au propre des notes du plan	Transcription des notes manuscrites	Vérifier que la lecture est correcte
Consignes de sécurité	Suggestions de précautions générales	Le danger réel sur cette machine, cette matière
Validation de la version finale	Jamais	Le responsable d’atelier relit toujours

Le principe tient en une ligne. L’IA est « celle qui met en texte », l’humain est « celui qui décide si c’est juste ». Une cote fausse, c’est un rebut. Une tolérance mal lue, c’est un souci chez le client. Donc tout ce qui touche aux chiffres passe sous l’œil d’un humain à la fin. Là-dessus, je ne cède pas.

Cas d’usage 1 : enregistrer un ancien pour en faire un mode opératoire

C’est celui qui a le plus d’effet et qui coince le moins. La méthode est simple.

On demande à l’ancien de raconter, pendant qu’il travaille, « ce qu’il est en train de faire ». On enregistre avec le dictaphone du téléphone, c’est tout. « D’abord je serre la pièce dans le mandrin, je fais le centrage… » : il suffit qu’il dise à voix haute ce qu’il fait d’habitude. Une opération de dix minutes, c’est dix minutes d’enregistrement.

On transcrit l’audio, puis on le donne à Claude Code. Ce prompt s’utilise tel quel :

Tu es chargé de rédiger la documentation technique d'un atelier de fabrication.
Voici la transcription d'un opérateur expérimenté parlant pendant l'usinage.
Mets cela en forme dans un modèle de « mode opératoire ».

Règles :
- Numérote chaque étape.
- Pour chaque étape, sépare « action », « point de vigilance » et « montage / outil utilisé ».
- Les valeurs citées par l'opérateur (cotes, vitesse, avance) : ne les modifie pas,
  conserve-les telles quelles en ajoutant [À VÉRIFIER].
- Pour tout passage flou, ne comble pas par déduction : écris « ※ à confirmer ».
- Garde les termes techniques et ajoute une ligne de note pour les débutants.

Transcription :
(coller la transcription ici)

Ici, deux consignes comptent : « ne modifie pas les valeurs » et « si c’est flou, ne comble pas ». L’IA, par souci de bien faire, va proposer un chiffre manquant : « ce doit être à peu près ça ». Dans un atelier, c’est dangereux. Donc on impose l’étiquette [À VÉRIFIER], et un humain les passe en revue une à une ensuite.

Ce qui change avant et après

Avant, faire un mode opératoire, c’était « quelqu’un dégage du temps et rédige tout depuis zéro ». Du coup, c’était sans cesse repoussé.

Après, l’ancien « parle pendant qu’il travaille, comme d’habitude », point. La partie lourde, mettre en texte, c’est l’IA qui la fait. L’humain ne fait plus que vérifier et corriger les chiffres du brouillon. Écrire de zéro et corriger un brouillon, ce n’est pas du tout le même poids mental.

Cas d’usage 2 : numériser les notes en marge des plans

« Beaucoup d’huile », « chanfrein à surveiller », griffonnés dans la marge du plan. C’est le savoir le plus fragile. Le jour où le plan est remplacé, les notes disparaissent avec.

La marche à suivre :

1. Photographier le plan annoté avec le téléphone (le nom du client et le numéro de plan peuvent apparaître : à ce stade, l’image reste en local).
2. Donner l’image à un Claude multimodal (via Claude.ai ou Claude Code) pour transcrire l’écriture manuscrite.
3. En relisant la transcription, demander à l’ancien : « pourquoi beaucoup d’huile, ici ? »
4. Ajouter la raison et sauvegarder sous forme de « carnet d’usinage » par référence.

L’étape 3 est le cœur. La note « beaucoup d’huile » seule ne dit rien à une recrue. Si on garde la raison — « cette matière est collante, les copeaux s’accrochent, donc on met plus d’huile » — alors seulement cela devient un savoir. Le temps gagné en faisant transcrire par l’IA, on le réinvestit dans ce « temps pour demander le pourquoi ».

Voici aussi un modèle de prompt pour mettre les notes du plan au propre :

Ceci est une note manuscrite en marge d'un plan de pièce.
Retranscris les caractères lisibles tels que tu les lis, sans rien déduire.
Pour tout passage illisible, indique clairement « (illisible) ».
Ensuite, pour chaque note, ajoute une question à poser à l'opérateur.
Ne complète jamais les valeurs de cotes ou de tolérances.

« Tels que tu les lis » et « ne complète pas » : il faut les remettre à chaque fois. Sans ça, l’IA transforme une écriture difficile en « caractères qui paraissent corrects », et on ne repère plus l’erreur.

Cas d’usage 3 : faire l’inventaire des modes opératoires existants

Le troisième, c’est de ranger les vieux modes opératoires déjà là. Dans beaucoup d’ateliers, des fichiers tableur ou traitement de texte traînent éparpillés dans les dossiers. On veut d’abord savoir où se trouve quoi.

Un petit script de vérification aide ici. Il liste les fichiers de modes opératoires sous un dossier donné, avec leur date de dernière modification, et les sort en tableau. Si Node.js est installé, il tourne.

import { readdir, stat } from "node:fs/promises";
import path from "node:path";

// Indiquer le dossier où sont rangés les modes opératoires
const root = process.argv[2] || ".";
// Extensions considérées comme des modes opératoires
const targets = [".xlsx", ".xls", ".doc", ".docx", ".pdf", ".txt"];

async function walk(dir) {
  const rows = [];
  for (const name of await readdir(dir)) {
    const full = path.join(dir, name);
    const info = await stat(full);
    if (info.isDirectory()) {
      rows.push(...(await walk(full)));
    } else if (targets.includes(path.extname(name).toLowerCase())) {
      const updated = info.mtime.toISOString().slice(0, 10);
      rows.push({ file: full, updated, kb: Math.round(info.size / 1024) });
    }
  }
  return rows;
}

const rows = await walk(root);
// Trier du plus ancien au plus récent (les plus anciens sont à revoir en priorité)
rows.sort((a, b) => a.updated.localeCompare(b.updated));
console.log("Dernière modif.\tTaille Ko\tFichier");
for (const r of rows) console.log(`${r.updated}\t${r.kb}\t${r.file}`);
console.log(`\nTotal : ${rows.length} mode(s) opératoire(s) trouvé(s).`);

Pour l’exécuter, on passe simplement le dossier cible en argument : node list-sop.mjs "C:\Dossier modes operatoires". Une fois la liste affichée, on vérifie avec l’atelier, en partant des plus anciens : « celui-ci, on l’utilise encore ? ». Rien qu’en supprimant les modes opératoires inutilisés, la confusion sur le terrain baisse nettement.

Ce script ne fait que dresser une liste : il ne modifie rien. On peut donc le relancer sans risque autant de fois qu’on veut. Les bases de Claude Code sont rassemblées dans le guide Claude Code pour débuter : si vous touchez un terminal pour la première fois, lisez-le d’abord.

Sécurité et données personnelles

Négliger ce point, c’est perdre la confiance elle-même. Les plans qu’un atelier manipule sont la propriété intellectuelle du client. Référence, cotes, conditions d’usinage : s’ils filent à un concurrent, c’est un gros problème.

Trois lignes à tenir :

1. Ne pas téléverser à la légère sur une IA grand public gratuite une image ou un PDF de plan où figurent le nom du client et le numéro de plan. Certaines conditions d’utilisation précisent que « les saisies servent à l’entraînement ». Pour un usage professionnel, choisir un service avec un contrat ou un réglage qui n’utilise pas les données pour l’entraînement.
2. Mettre en place une routine qui retire des transcriptions et des modes opératoires toute information identifiant le client. Remplacer la référence par un code interne, masquer le numéro de plan : standardiser ce petit effort.
3. Avant de donner quoi que ce soit à l’IA, se demander une fois « cette information peut-elle sortir sans danger ? ». Dans le doute, on ne sort pas. Rien que ça évite la plupart des incidents.

Cette façon de penser — « quoi montrer à l’IA, quoi ne pas montrer » — est aussi abordée dans Claude Code pour les non-développeurs. C’est le réflexe qu’un responsable d’atelier doit acquérir en premier. Pour cadrer une règle interne, la documentation de la CNIL sur l’IA propose des repères publics utiles sur la protection des données.

Un repère simple de retour sur investissement

Sans chiffres, ni l’atelier ni le patron ne bougent. À la louche, voici un repère.

Rédiger un mode opératoire à la main, depuis zéro, prend bien une demi-journée (4 heures) entre le recueil et la mise au propre — c’est mon ressenti. En le remplaçant par « 10 minutes où l’ancien parle + mise en forme par l’IA + 1 heure de vérification humaine », on tombe à environ 1,5 heure. Soit 2,5 heures gagnées par mode opératoire.

Élément	Avant	Après
Temps par mode opératoire	environ 4 h	environ 1,5 h
Pour 50 par an	200 h	75 h
Temps gagné	—	environ 125 h

125 heures par an, c’est proche de trois semaines de travail d’une personne. Et s’y ajoute un effet qui dépasse le simple gain de temps : « on parvient enfin à produire des modes opératoires qu’on n’arrivait pas à faire ». Le coût se limite à la transcription et à l’usage de l’IA générative, à partir de quelques euros par mois. Le retour devrait être très rapide.

FAQ

Q. Un ancien fâché avec l’informatique peut-il s’en servir ? R. L’ancien n’a pas besoin de piloter l’IA lui-même. Tout ce qu’il fait, c’est « parler ». L’enregistrement et la mise en forme, c’est le responsable d’atelier ou la personne au bureau qui s’en charge. En répartissant les rôles, on embarque aussi ceux que la machine rebute.

Q. La précision de la transcription m’inquiète. R. Sur les termes techniques ou les expressions locales, il y aura des erreurs. Donc on ne vise pas la perfection : on traite ça comme « une base de brouillon ». En partant du principe qu’un humain corrige, c’est tout de même bien plus rapide que d’écrire de zéro.

Q. Les notes manuscrites sont trop brouillonnes, même l’IA n’y arrivera pas ? R. Ce qui est illisible, on lui fait répondre honnêtement « illisible ». Là, il faut bien le demander à celui qui l’a écrit. L’avantage, c’est de pouvoir le faire tant que la personne est encore en poste. Une fois qu’elle est partie, c’est trop tard.

Q. Le jeu en vaut-il la chandelle pour un petit atelier ? R. C’est même là que ça marche le mieux. Peu de monde = un départ frappe fort. Sortir d’une dépendance à une personne est d’autant plus vital que l’atelier est petit.

Q. Je veux mieux formuler mes instructions. R. En affinant la qualité des prompts, on réduit encore les retours en arrière. La conception de prompts Claude Code (niveau avancé) rassemble des façons concrètes de construire vos instructions.

Ce que j’ai constaté en l’essayant

Dans un atelier d’usinage que je connais, on a essayé ensemble le cas d’usage 1, « enregistrer pour en faire un mode opératoire ». La cible : le réglage d’un certain montage, fait par un ancien proche de la retraite.

Enregistrement : 12 minutes. Le temps de donner la transcription à Claude Code et d’obtenir un modèle de mode opératoire : quelques minutes. Le brouillon sorti portait un [À VÉRIFIER] sur chaque vitesse et chaque avance, et on a passé ces points en revue avec l’ancien en une heure environ. Ce que je croyais être un travail d’une demi-journée s’est terminé dans la matinée.

Le plus intéressant : l’IA a signalé un oubli — « cette étape, il manque l’explication de pourquoi cet ordre ». Et l’ancien : « ah, ça, je le faisais sans y penser ». Un réglage si évident qu’il n’avait jamais été mis en mots est remonté à la surface grâce à la question de l’IA. Voilà un gain que je n’avais pas anticipé.

Si vous voulez en faire un vrai dispositif de transmission du savoir à l’échelle de l’entreprise, fixez d’abord les règles et le traitement des données. Pour creuser ces points en formation ou en accompagnement individuel, voyez la page formation et accompagnement. Mais le premier pas le plus rapide, c’est d’essayer un seul mode opératoire dans votre atelier, sur un cas où une erreur ne porterait pas à conséquence.