Les Do-Nothing Scripts : une nouvelle approche pour les procédures manuelles

septembre 2025

Cet article est la transcription de la conférence que j’ai donnée au meetup Software Crafters Rennes en septembre 2025. J’ai repris mes slides et mes notes pour en faire un texte qui se lit tout seul. Le replay est sur YouTube si vous préférez.

Une histoire qui commence en 2019

Tout part d’un article de Dan Slimmon, publié en juillet 2019. Il a fait surface sur Hacker News trois fois : en 2019, en 2021, puis à nouveau en 2025. C’est rare qu’un article ressorte comme ça, et c’est en le revoyant passer que je me suis dit qu’il méritait un talk.

Le problème

Slimmon décrit une catégorie de tâches très précise :

Certaines tâches demandent beaucoup d’attention, mais très peu de réflexion. Elles exigent toute notre concentration, mais cette concentration n’est pas récompensée par des problèmes intéressants ou des solutions satisfaisantes.

L’exemple qu’il prend : créer un accès pour un nouvel arrivant.

  1. Créer une paire de clés SSH pour l’utilisateur.
  2. Committer la clé publique sur le dépôt et la pousser.
  3. Attendre que le build soit terminé.
  4. Retrouver l’adresse e-mail de la personne dans le LDAP.
  5. Lui envoyer sa clé privée via 1Password.

Cinq étapes, aucune n’est difficile, mais il faut les faire dans l’ordre, sans en oublier, et souvent sous la pression d’un « au fait, le nouveau arrive lundi ». C’est le genre de procédure où on se trompe non pas par incompétence, mais par fatigue.

La mauvaise idée : tout automatiser

Le réflexe, c’est d’écrire un script qui fait les cinq étapes tout seul. Sauf que :

  • c’est long à écrire, pour une procédure qu’on lance une fois par mois ;
  • ça ne supprime jamais complètement le manuel — il reste toujours une étape qui dépend d’un humain, d’un outil tiers, d’une validation.

On investit beaucoup pour un résultat partiel.

La bonne idée : automatiser la validation des étapes

Le do-nothing script inverse le problème. Au lieu d’automatiser le travail, on automatise le déroulé.

Un script « do-nothing » est un script qui encode les instructions d’une procédure, en encapsulant chaque étape dans une fonction.

Concrètement, le script n’exécute rien. Il affiche l’étape courante, attend que vous appuyiez sur Entrée, puis passe à la suivante. Voici la version de l’article, en Python :

import sys

def wait_for_enter():
    input("Appuyez sur Entrée pour continuer : ")

class CreateSSHKeypairStep:
    def run(self, context):
        print("Lancer :")
        print(f"   ssh-keygen -t rsa -f ~/{context['username']}")
        wait_for_enter()

class GitCommitStep:
    def run(self, context):
        print("Copier ~/new_key.pub dans le dépôt user_keys, puis :")
        print(f"    git commit {context['username']}")
        print("    git push")
        wait_for_enter()

class WaitForBuildStep:
    build_url = "http://example.com/builds/user_keys"
    def run(self, context):
        print(f"Attendre la fin du build : {self.build_url}")
        wait_for_enter()

class RetrieveUserEmailStep:
    def run(self, context):
        print("Ouvrir l'annuaire et trouver l'e-mail de l'utilisateur")
        context["email"] = input("Coller l'adresse et appuyer sur Entrée : ")

class SendPrivateKeyStep:
    def run(self, context):
        print("Ouvrir 1Password, coller ~/new_key dans un nouveau document")
        print(f"Partager le document avec {context['email']}")
        wait_for_enter()

if __name__ == "__main__":
    context = {"username": sys.argv[1]}
    procedure = [
        CreateSSHKeypairStep(),
        GitCommitStep(),
        WaitForBuildStep(),
        RetrieveUserEmailStep(),
        SendPrivateKeyStep(),
    ]
    for step in procedure:
        step.run(context)
    print("Terminé.")

Ça a l’air bête, et ça l’est un peu. Mais chaque étape est maintenant une fonction nommée, versionnée, relue en revue de code. Le jour où vous voulez automatiser réellement l’étape 3, vous remplacez le contenu de WaitForBuildStep.run() et le reste ne bouge pas. C’est de l’automatisation incrémentale : on avance fonction par fonction, quand on en a le temps.

Ce qu’on y gagne

  • On peut automatiser petit à petit, sans big bang.
  • On finit souvent par écrire une petite bibliothèque interne d’étapes réutilisables.
  • La charge mentale baisse : on suit une liste au lieu de tout tenir en tête, donc on fait moins d’erreurs.
  • La procédure devient un artefact de code : elle se relit, se commente, se diffe.
  • Si une étape est trop grosse pour tenir dans une fonction claire, c’est le signe qu’il faut la découper.

Ce que ça coûte

La communauté Hacker News a été assez critique, et à raison :

  • une procédure figée dans un script a tendance à ne plus jamais bouger — on « grippe » le système ;
  • le déroulé n’est pas interruptible proprement, et on n’a aucune vue d’ensemble ni estimation de durée ;
  • en automatisation partielle, un script peut « dérailler » sur une entrée inattendue (un e-mail saisi avec une faute de frappe, par exemple) ;
  • une fois la procédure bien maîtrisée, plus personne ne relit le script, alors qu’il continue d’évoluer ;
  • les critères qui valident une étape restent implicites : « appuyez sur Entrée quand c’est bon » suppose qu’on sait ce que « bon » veut dire ;
  • et, accessoirement, le nom « do-nothing » est trompeur : le script fait quelque chose, il orchestre.

Les outils

Selon le niveau d’automatisation visé :

  • Rien du tout : un script maison de trente lignes suffit très souvent.
  • Runbook : bibliothèque Ruby de Braintree pour des do-nothing scripts partiellement automatisés.
  • XL Release : plutôt une CI pour scripts partiellement automatisés, qui exécute les étapes auto et notifie les humains pour les autres.
  • xc : les étapes sont décrites dans un fichier Markdown qui sert à la fois de doc et de script.
  • Speedrun : de la documentation Markdown à laquelle on ajoute des commandes exécutables.
  • Et, forcément, des générateurs de do-nothing scripts par IA.

Pour aller plus loin

Après le talk, j’ai bricolé une petite implémentation Python qui charge un workflow depuis un fichier Markdown (un titre #, une étape par ##), journalise chaque étape validée, et permet de reprendre un run interrompu là où il s’était arrêté. Rien de sérieux, mais ça montre qu’on passe vite du concept à quelque chose d’utilisable.

L’idée à retenir : entre la procédure dans un wiki que personne ne suit et l’automatisation complète qu’on n’a jamais le temps d’écrire, le do-nothing script est un intermédiaire honnête. Il rend la procédure exécutable et versionnée, et il laisse la porte ouverte pour automatiser le jour où ça en vaut la peine.

Sources