L'IA qui code, version grown-up

La plupart des devs ont fait peace avec leurs assistants IA. Ils génèrent du code, ils aident à débugger, parfois ils proposent des améliorations sympas. Mais quand quelque chose se passe mal ? Retour à zéro. L'historique de conversation dort dans une base opaque. Le raisonnement de l'agent s'évapore quand tu fermes la session.

Ce modèle est cassé. Et le problème vient de notre rapport à Git.

Git, ce n'est pas un backup

La plupart des développeurs voient Git comme un outil de versioning basique. Raté. Git, c'est une machine à états avec un journal de conversation intégré. Chaque commit capture pas juste ce qui a changé, mais le contexte qui a mené à ce changement. Les branches, ce sont des réalités alternatives. Les worktrees te laissent exister à plusieurs endroits en même temps.

Maintenant, imagine un agent IA qui comprend cette architecture nativement.

Au lieu de maintenir une base de données interne opaque, chaque action de ton assistant est commitée dans le repo avec l'historique complet des chats et des exécutions. Tu veux revoir une approche précédente ? Tu checkouts un commit. Tu veux explorer un design alternatif ? Tu crées une branche avec un worktree frais. Pas d'abandon, pas de confusion.

Ce n'est pas un détail d'implémentation. C'est un changement de paradigme complet.

Ce que ça change concrètement

Les branches, vraiment utiles cette fois

Avec un agent classique, explorer une alternative signifie soit lâcher ta direction actuelle, soit maintenir un état de plus en plus bordélique. Avec un agent Git-native, le branching ouvre un contexte isolé dans un worktree. Tu veux tester ce refactoring dingue ? Vas-y, ça ne touche pas ton checkout stable. Ça marche ? Merge. Ça marche pas ? Supprime la branche, reviens pile où tu étais.

La récupération de session qui fonctionne vraiment

Combien de fois t'as perdu une session de debug productive à cause d'un onglet fermé par erreur ou d'un crash ? Chaque étape qui modifie des fichiers est snapshotée avec l'historique du chat. Rewind vers n'importe quel checkpoint ? Trivial. Tu ne espères pas que le système ait préservé ton état — tu vois littéralement les commits dans ton repo.

Switcher de config en plein vol

Les meilleurs développeurs alternent entre plusieurs modes mentaux dans la journée. Architecture, implémentation, review. Un agent Git-native peut swapper entre différentes configurations — planner, coder, reviewer — sans perdre ton contexte actif. Les transitions sont propres parce que l'état vit dans Git.

Exploration parallèle pour de vrai

Faire tourner plusieurs agents en même temps ? Pas de la science-fiction quand ton architecture repose sur des worktrees. Plusieurs approches explorées simultanément, chacune dans son propre environnement isolé, avec des résultats comparables, fusionnables ou abandonnables indépendamment.

L'impact sur l'expérience développeur

Il y a un angle psychologique qu'on néglige souvent. Quand ton assistant IA opère dans un système opaque, tu développes une forme d'impuissance apprise vis-à-vis de son état. Tu arrêtes de demander "mais qu'est-ce qu'on faisait hier ?" parce que la réponse implique de naviguer dans des interfaces faites pour autre chose.

Quand ton agent vit dans Git, la barrière d'entrée tombe à zéro. Tu sais déjà utiliser les branches. Tu sais déjà faire un diff. Tu sais déjà checkout. La courbe d'apprentissage s'aplatit parce que tu étends des workflows familiers au lieu d'en adopter de entièrement nouveaux.

Pour les équipes, c'est encore plus мощный. L'historique de développement complet devient searchable, auditable, recoverable. Onboarder un nouveau dev, ça ne veut pas dire expliquer un système d'historique d'agent propriétaire. Ça veut dire "voici notre repo, et au fait, voici ce que l'IA avait en tête à chaque commit."

Les outils qui rendent ça possible

Les agents Git-native modernes supportent plusieurs backends de modèles — modèles locaux via des outils comme mlx-lm, providers cloud comme Gemini, Claude et compagnie — avec un toolkit robuste d'opérations fichiers, commandes shell et recherche. L'abstraction fonctionne parce qu'elle repose sur les primitives éprouvées de Git plutôt que d'essayer de les recréer.

Les raccourcis clavier feels natifs parce qu'ils mappent sur des opérations que les développeurs font déjà : jumper entre tabs maps to switching contexts, diffing montre exactement ce qui a changé, et l'historique c'est juste... de l'historique.

Ce qui nous attend

On entre dans une ère où les outils de développement assistés par IA doivent grandir. Les démos proof-of-concept, c'est bien beau. Mais les outils qui vont rester sont ceux qui respectent comment les développeurs bossent déjà. Les agents Git-native ne te demandent pas de changer ton workflow pour accommoder l'IA. Ils étendent ton infrastructure existante avec des super-pouvoirs IA.

La question n'est pas de savoir si l'IA va devenir intégrale aux workflows de dev — c'est déjà le cas. La question c'est si ces intégrations vont feel comme des corps étrangers vissés sur des outils familiers, ou des extensions naturelles de systèmes que les développeurs font déjà confiance.

Pour ceux d'entre nous qui se sont fait avoir par des états d'agents opaques et des sessions perdues, le raisonnement Git-native feel moins comme de l'innovation et plus comme du bon sens.