Welcome mise-en-place!
Pourquoi Make et Gradle ont cessé d'orchestrer mes projets, et comment mise (tâches, versions et environnement dans un seul fichier) a pris le relais, surtout avec les agents IA.
Sommaire
- Make et Gradle savent lancer des commandes, mais aucun ne s’occupe de ce qui les entoure : les versions des outils et l’environnement.
- mise réunit les tâches, les versions des outils et les variables d’environnement dans un seul
mise.toml. Unmise installsuffit à préparer une machine. - Gradle continue de builder du Kotlin. mise orchestre tout ce qu’il y a autour, de la même façon pour moi, pour la CI et pour les agents IA.
Pendant des années, j’ai démarré mes projets de la même façon : un Makefile à la racine. Pas pour compiler du C, mais pour offrir un point d’entrée unique. make setup, make test, make lint, make deploy. Peu importe le langage ou le framework, n’importe qui arrivant sur le projet savait par où commencer.
Et sur mes projets Android, ce rôle revenait à Gradle : tout passait par ./gradlew, y compris ce qui n’avait rien à voir avec la compilation.
Ça a bien fonctionné. Jusqu’au jour où j’ai réalisé que je passais plus de temps à contourner ces outils qu’à m’en servir. Aujourd’hui, tous mes projets utilisent mise à la place. Le nom vient de la « mise en place », ce moment où un cuisinier prépare tout son poste avant le service. Dans cet article, je reviens sur trois choses :
- pourquoi j’utilisais Make et Gradle, et pourquoi chacun a fini par me poser problème ;
- pourquoi mise est selon moi la bonne réponse : des tâches, des versions et un environnement, simplement ;
- pourquoi c’est encore plus intéressant à l’époque des agents IA.
1. Make et Gradle : de bons réflexes, de mauvais chefs d’orchestre
Pourquoi j’utilisais Make
Make avait trois qualités difficiles à battre :
- Il est partout. Préinstallé sur macOS et sur la plupart des distributions Linux, il n’y a rien à installer.
- Tout le monde connaît la convention. Personne n’a besoin de lire une doc pour taper
make test. - Il est agnostique. Node, Python, Terraform, Docker : un
Makefileappelle n’importe quoi.
Là où Make coince
Il faut être honnête : Make est un outil de build orienté fichiers. Sa logique, c’est « reconstruis cette cible si ses dépendances sont plus récentes ». Quand on l’utilise comme lanceur de commandes, on se bat contre ce modèle :
- Les
.PHONYpartout, sinon un fichier nommétestà la racine casse silencieusementmake test. - Les tabulations obligatoires, et le message d’erreur cryptique quand ton éditeur a mis des espaces.
- Un shell par ligne : un
cdsur une ligne n’a plus d’effet sur la suivante, d’où les&& \en cascade. - Les arguments : passer un paramètre donne des choses comme
make deploy ENV=staging, et dès qu’on veut quelque chose de plus riche, ça devient pénible. - La portabilité : GNU Make, la vieille version fournie par macOS, Windows… Le même
Makefilene se comporte pas pareil partout.
Pourquoi j’utilisais Gradle
Si tu viens du monde Android, le point d’entrée n’est pas un Makefile, c’est Gradle. Et l’utiliser n’a rien d’absurde :
- Il est déjà là. Un projet Android sans Gradle, ça n’existe pas. Ajouter une tâche dans le
build.gradle.ktssemblait plus simple qu’introduire un nouvel outil. - Le wrapper fige la version.
./gradlewtélécharge la bonne version de Gradle sans rien installer à la main. C’est exactement la promesse que je cherchais pour le reste de mes outils. - Un vrai graphe de tâches.
dependsOn, l’exécution incrémentale, le build cache : Gradle sait ne refaire que ce qui a changé, et il le fait très bien. - Un seul langage. Écrire ses tâches en Kotlin, dans l’IDE, avec l’autocomplétion, c’est confortable pour une équipe Kotlin.
- La CI suivait naturellement. Un
./gradlew checket c’était réglé.
Là où Gradle coince
Le problème apparaît dès qu’on demande à Gradle autre chose que compiler du Kotlin. Prenons un cas banal sur un projet multiplateforme : lancer SwiftLint, builder l’app iOS et regrouper les vérifications.
// build.gradle.kts (racine)
val swiftLint by tasks.registering(Exec::class) {
group = "verification"
description = "Lint du code Swift"
workingDir = file("iosApp")
commandLine("swiftlint", "--strict")
}
val buildIos by tasks.registering(Exec::class) {
group = "build"
description = "Build de l'app iOS pour le simulateur"
workingDir = file("iosApp")
commandLine(
"xcodebuild",
"-project", "iosApp.xcodeproj",
"-scheme", "iosApp",
"-destination", "generic/platform=iOS Simulator",
"build",
)
}
tasks.register("checkAll") {
group = "verification"
dependsOn(":shared:allTests", ":androidApp:lint", swiftLint)
}
Vingt-cinq lignes pour appeler deux commandes et les regrouper. Et la verbosité n’est que la partie visible :
- Gradle est un outil de build, pas un lanceur de commandes. Appeler un binaire passe par un type de tâche (
Exec), une API et des propriétés à configurer. On écrit du code pour décrire ce qu’une ligne de shell ferait. - Chaque appel paie le cycle de vie de Gradle. Avant d’exécuter quoi que ce soit, il faut démarrer ou rejoindre le daemon JVM, puis initialiser et configurer le build, avec ses modules et ses plugins. Pour lancer un linter qui tourne en une seconde, le détour est coûteux. Le configuration cache réduit ce coût, mais il impose ses propres règles sur ce qu’une tâche a le droit de faire.
- Gradle ne gère pas les outils hors JVM. Rien ne garantit que
swiftlintest installé, ni dans quelle version. Et même./gradlewa besoin d’un JDK déjà présent sur la machine pour démarrer.
Avec Kotlin Multiplatform, ces défauts deviennent quotidiens, parce que mon projet n’est plus un seul écosystème :
- le module partagé et l’app Android, buildés par Gradle ;
- l’app iOS, dans Xcode, avec ses propres outils (
xcodebuild, SwiftLint, Swift Package Manager) ; - fastlane, donc Ruby, pour publier sur les stores ;
- et selon les projets, un backend, un site, des scripts Python ou de l’infra.
Faire de Gradle le chef d’orchestre de tout ça revient à demander à l’un des musiciens de diriger tout l’orchestre.
Ce que Make et Gradle ont en commun
Les deux savent lancer des commandes. Aucun ne s’occupe vraiment de ce qui entoure ces commandes : les versions des outils et l’environnement. Make suppose que tout est déjà installé. Gradle gère sa propre version et les dépendances Kotlin, mais rien au-delà de la JVM.
Mon make setup supposait toujours que la bonne version de Node, de Python, de Terraform ou de Java était déjà installée. Résultat : un README avec une section « Prérequis » que personne ne lit, des versions qui divergent entre collègues, et le classique « chez moi ça marche ».
J’avais donc en réalité trois outils : un gestionnaire de versions (nvm, pyenv, asdf…), direnv ou un .env pour les variables d’environnement, et Make ou Gradle pour les commandes. Trois fichiers de config, trois choses à installer, trois sources de désynchronisation.
2. Pourquoi mise : des tâches, des versions, un environnement
mise répond à ces trois besoins avec un seul fichier, mise.toml. C’est ce qui me plaît le plus : il n’y a rien de plus à comprendre.
[tools]
node = "22"
python = "3.13"
terraform = "1.9"
[env]
_.file = ".env"
APP_ENV = "development"
[tasks.install]
description = "Installe les dépendances"
run = "npm ci"
[tasks.lint]
run = "npm run lint"
[tasks.test]
description = "Lance les tests"
depends = ["lint"]
run = "npm test"
[tasks.dev]
depends = ["install"]
run = "npm run dev"
Les tâches
Une tâche, c’est un nom, une description et une commande. Pas de .PHONY, pas de tabulations, pas de DSL : du TOML.
La découvrabilité. Comme ./gradlew tasks, mise tasks liste toutes les tâches avec leur description. Plus besoin d’ouvrir le fichier pour savoir ce qui existe.
Les dépendances et le parallélisme. depends déclare ce qui doit tourner avant, et mise lance les dépendances en parallèle. Pour lancer plusieurs tâches indépendantes d’un coup : mise run lint ::: test.
Les tâches sous forme de fichiers. Quand un script devient long, je le sors du TOML et je le mets dans un dossier mise-tasks/ : un vrai fichier shell (ou Python, ou autre), avec coloration syntaxique et lint, que mise expose comme une tâche.
Le cache. En déclarant sources et outputs sur une tâche, mise la saute si rien n’a changé. C’est la seule vraie force de Make, et je la retrouve là où j’en ai besoin.
Les versions
La section [tools] fige la version de chaque outil du projet : Node, Python, Java, Ruby, SwiftLint, Terraform… mise install installe tout d’un coup, et chaque projet garde ses propres versions sans interférer avec les autres. Dans mon terminal, les bonnes versions s’activent dès que j’entre dans le dossier du projet.
Pour aller plus loin, mise lock génère un mise.lock qui enregistre les versions exactes et leurs checksums, ce qui rend les installations reproductibles d’une machine à l’autre. Et parce que mise gère aussi le JDK, ./gradlew démarre avec le bon Java partout, sans réglage de JAVA_HOME.
L’environnement
La section [env] remplace direnv et les export à la main : variables du projet, chargement d’un .env, ajout d’un dossier au PATH. Ces variables s’appliquent dans mon shell comme dans les tâches.
Deux détails que j’utilise tous les jours :
mise.local.tomlpour mes surcharges personnelles, ignoré par Git ;MISE_ENV=stagingpour chargermise.staging.tomlpar-dessus la config de base, sans dupliquer le reste.
C’est simple
L’onboarding d’un nouveau développeur tient en deux lignes :
mise install
mise run dev
mise installe les bonnes versions des outils, charge les variables d’environnement, puis exécute la tâche avec cet environnement. Plus de section « Prérequis » dans le README.
Face au Makefile que j’écrivais avant, le même besoin se résume ainsi :
| Makefile | mise | |
|---|---|---|
| Lancer une tâche | make test | mise run test (ou mise test) |
| Lister les tâches | à la main, ou une cible help bricolée | mise tasks |
| Versions des outils | hors périmètre | [tools], installées automatiquement |
| Variables d’env | export ou direnv | [env], .env chargé nativement |
| Dépendances entre tâches | cibles prérequises | depends |
| Parallélisme | make -j, avec ses surprises | natif, et mise run lint ::: test |
| Syntaxe | tabulations, .PHONY, $$ | TOML lisible ou scripts shell classiques |
Et voici ce qui se passe réellement quand on lance une tâche :
Sur un projet Kotlin Multiplatform
Le même besoin que l’exemple Gradle plus haut, avec mise :
[tools]
java = "temurin-21"
ruby = "3.3"
swiftlint = "0.57"
[tasks."shared:test"]
description = "Tests du module partagé, toutes cibles"
run = "./gradlew :shared:allTests"
[tasks."android:lint"]
run = "./gradlew :androidApp:lint"
[tasks."ios:lint"]
dir = "iosApp"
run = "swiftlint --strict"
[tasks."ios:build"]
dir = "iosApp"
run = """
xcodebuild -project iosApp.xcodeproj -scheme iosApp \
-destination 'generic/platform=iOS Simulator' build
"""
[tasks."ios:beta"]
dir = "iosApp"
run = "bundle exec fastlane beta"
[tasks."gradle:check"]
description = "Tests partagés et lint Android, en un seul appel Gradle"
run = "./gradlew :shared:allTests :androidApp:lint"
[tasks.check]
description = "Toutes les vérifications, Android et iOS"
depends = ["gradle:check", "ios:lint"]
Ce que ça change au quotidien :
- Le JDK, Ruby et SwiftLint sont versionnés au même endroit. Un nouveau développeur iOS fait
mise installcomme tout le monde. - Les tâches iOS ne réveillent plus le daemon Gradle.
mise run ios:lintlance SwiftLint directement. mise run checklance Gradle et SwiftLint en parallèle. Côté Gradle, un seul appel regroupe les tests et le lint : deux./gradlewsimultanés sur le même projet démarreraient deux daemons qui se disputent les mêmes verrous.- Les noms de tâches parlent à tout le monde.
mise tasksafficheandroid:*,ios:*etshared:*, que l’on vienne de Kotlin ou de Swift.
Je n’ai pas remplacé Gradle. Il compile, teste, résout les dépendances Kotlin et met en cache, et il le fait mieux que n’importe quel autre outil. Ce que je lui ai retiré, c’est le rôle de chef d’orchestre : mise est au-dessus, et Gradle devient l’un des outils qu’il appelle.
| Gradle comme orchestrateur | mise comme orchestrateur | |
|---|---|---|
| Lancer un outil hors JVM | une tâche Exec en DSL Kotlin | une ligne run |
| Coût d’un appel | daemon JVM et configuration du build | lancement direct de la commande |
| Versions des outils hors JVM | non gérées | [tools] |
| JDK pour démarrer | doit déjà être installé | installé par mise |
| Build incrémental du code Kotlin | excellent | délégué à Gradle |
La règle que j’applique désormais est simple : si ça compile du Kotlin, c’est Gradle. Si ça orchestre, c’est mise.
Monorepos et CI
Les monorepos. C’est ce qui m’a définitivement convaincu. Avec monorepo_root = true et la liste des sous-projets à la racine, chaque sous-projet garde son propre mise.toml :
# mise.toml (racine)
monorepo_root = true
[monorepo]
config_roots = ["apps/api", "apps/web"]
[tools]
node = "24"
Je peux ensuite lancer n’importe quelle tâche depuis n’importe où :
mise //apps/api:test # les tests de l'API
mise //...:lint # le lint de tous les projets
Chaque tâche s’exécute avec les outils et l’environnement de son projet. L’API peut rester sur Node 22 pendant que le front passe à Node 24, sans aucune gymnastique.
La CI alignée sur le local. En CI, j’utilise l’action GitHub jdx/mise-action, puis les mêmes mise run qu’en local. La CI ne réinvente plus sa propre façon d’installer les outils.
3. Pourquoi c’est encore plus intéressant à l’époque de l’IA
Aujourd’hui, une partie de mon code est écrite, testée et corrigée par des agents comme Claude Code ou Codex. Un agent, c’est un nouveau développeur qui arrive sur le projet plusieurs fois par jour, sans mémoire de la veille. Tout ce qui aide un humain à démarrer l’aide encore plus.
Un seul contrat pour trois consommateurs : moi, la CI et l’agent.
Un point d’entrée qu’un agent découvre seul
Sans convention, un agent devine : ./gradlew ou npm ? xcodebuild avec quels paramètres ? Depuis quel dossier ? Il tâtonne, se trompe, recommence. Avec mise, mise tasks lui donne la liste des actions possibles avec leur description, et le mise.toml se lit en quelques secondes.
Du coup, la partie « commandes » de mon AGENTS.md (ou CLAUDE.md) tient en quelques lignes :
## Commandes
- Installer l'environnement : `mise install`
- Lister les tâches disponibles : `mise tasks`
- Avant de proposer un changement : `mise run check`
- Ne lance pas `./gradlew` ou `xcodebuild` directement : passe par les tâches mise.
Moins de code à lire, moins d’erreurs
Quand je demande à un agent d’ajouter une vérification, il y a deux mondes. Côté Gradle : une tâche Exec, un dependsOn, la compatibilité avec le configuration cache, et un build complet à relancer pour vérifier que rien n’est cassé. Côté mise : une ligne de TOML. Moins de contexte à charger, moins de tokens, moins de chances de casser le build. Et relire un diff de trois lignes de TOML me prend dix secondes.
Le même environnement pour l’agent que pour moi
Les agents travaillent dans des shells non interactifs, souvent dans des worktrees Git, parfois dans des sandbox dans le cloud. Sans gestion des versions, chacun de ces environnements est une nouvelle occasion de tomber sur le mauvais JDK ou un SwiftLint absent. Avec mise, mise install donne à l’agent exactement les mêmes versions que moi et que la CI.
Une subtilité à connaître : un shell non interactif n’exécute pas mise activate. La doc de mise propose pour Claude Code un hook qui charge l’environnement du projet avant chaque commande :
{
"hooks": {
"SessionStart": [
{
"hooks": [
{
"type": "command",
"command": "[ -n \"$CLAUDE_ENV_FILE\" ] && echo 'eval \"$(mise hook-env -s bash)\"' >> \"$CLAUDE_ENV_FILE\"; true"
}
]
}
]
}
}
Si ton agent lance ses commandes dans zsh, remplace -s bash par -s zsh. L’alternative, préfixer chaque commande par mise x --, fonctionne aussi, mais elle alourdit chaque appel et les agents finissent par l’oublier.
Bonus pour les worktrees : les outils sont installés dans le dossier de données de mise, pas dans le projet, donc un nouveau worktree ne réinstalle rien.
Une boucle de feedback rapide
Un agent lance les vérifications des dizaines de fois par session. Chaque seconde de démarrage se multiplie d’autant. Les tâches qui n’ont pas besoin de Gradle (SwiftLint, formatage, scripts) partent immédiatement, et le cache sources / outputs saute ce qui n’a pas changé. L’agent itère plus vite, et moi j’attends moins.
Des garde-fous
Les tâches définissent un vocabulaire : l’agent lance check ou ios:lint, pas des commandes improvisées. Je peux autoriser mise run sans validation dans les permissions de l’agent et garder le reste sous contrôle, à condition de relire les changements qu’il apporte au mise.toml.
mise va plus loin avec mise mcp, un serveur MCP qui permet à un assistant de lire les outils, les tâches, l’environnement et la config du projet, et de lancer ses tâches :
claude mcp add mise -- mise --cd /chemin/vers/projet mcp
L’outil de lancement prend un nom de tâche, pas un script arbitraire, et il refuse de tourner sur un projet dont la config n’a pas été approuvée avec mise trust. Pour laisser un assistant explorer un projet sans rien exécuter, MISE_SAFE=1 coupe l’exécution tout en gardant la lecture des outils, des tâches et de la config.
Les points d’attention
Tout n’est pas gratuit, et je préfère être transparent :
- C’est un outil de plus à installer. Make est présent partout, mise non. En pratique, c’est la seule chose à installer à la main, puisque c’est lui qui installe tout le reste.
- Le
mise trust. Unmise.tomlpeut exécuter du code (hooks, variables calculées…). mise demande donc d’approuver la config d’un dépôt avant de l’appliquer. C’est une bonne chose côté sécurité, mais ça surprend la première fois. - L’adoption par l’équipe. Tout le monde connaît
makeet./gradlew. Il faut quelques jours pour quemise rundevienne un réflexe. - Les agents demandent un petit réglage. Sans le hook ou
mise x --, leur shell non interactif ne voit pas les outils du projet. - Make et Gradle restent pertinents pour ce pour quoi ils ont été conçus : de vrais builds basés sur des fichiers pour Make, la compilation Kotlin et Android pour Gradle. Mon reproche ne vise que leur usage comme chefs d’orchestre.
En résumé
Make et Gradle m’ont longtemps servi de point d’entrée, mais ils ne savaient faire qu’un tiers du travail : lancer des commandes. Les versions des outils et l’environnement restaient à gérer ailleurs, et Gradle ajoutait sa verbosité et son coût de démarrage dès qu’on sortait de la JVM.
mise réunit les trois dans un seul fichier : des tâches, des versions, un environnement. Une seule commande pour démarrer, la même chose en local et en CI. Et sur mes projets Kotlin Multiplatform, Gradle n’a pas disparu : il a simplement arrêté de tout orchestrer pour se concentrer sur ce qu’il fait le mieux, builder du Kotlin.
À l’heure où une partie du travail est faite par des agents, ce contrat simple et lisible vaut encore plus : ce qui est clair pour un humain l’est aussi pour une IA.
Si tu as un Makefile qui ne contient que des .PHONY, ou un build.gradle.kts rempli de tâches Exec, essaie de les convertir sur un petit projet. Il y a de bonnes chances que tu ne reviennes pas en arrière.