Git Worktrees permet le développement parallèle sur plusieurs branches simultanément. Combinés à des agents de codage IA, ils ouvrent des possibilités entièrement nouvelles pour des workflows efficaces et capables de monter en charge, comme avoir une équipe de développement virtuelle sur une seule machine.

En tant qu'architectes logiciels et développeurs chez vensas, nous faisons souvent face au défi de travailler simultanément sur plusieurs fonctionnalités, corrections de bugs ou idées. L'approche traditionnelle avec git checkout implique de changer constamment de branche, de stasher des modifications ou de créer des commits "work in progress", autant de pertes de temps qui cassent le flow.

Dans cet article, nous montrons comment Git Worktrees combiné à des agents de codage IA, comme GitHub Copilot, Claude Code ou Cursor, peut faire passer le développement à un tout autre niveau.

Qu'est-ce que Git Worktrees ?

Git Worktrees permet de créer plusieurs répertoires de travail à partir d'un même dépôt, chaque répertoire étant checkouté sur une branche différente. Contrairement à git checkout, il n'y a pas de limitation à une seule branche active par répertoire de travail. On peut donc travailler simultanément sur plusieurs fonctionnalités, corrections de bugs ou expériences, chacune isolée dans son propre dossier, tout en partageant le même historique de dépôt et les mêmes données .git.

Les avantages en un coup d'œil

Véritable parallélisme : pas de context switching, de stashing ou d'écrasements accidentels
Faible empreinte de stockage : tous les worktrees partagent le même historique .git, contrairement à plusieurs clones
Intégration Git transparente : toutes les branches et tout l'historique restent cohérents
Parfait pour l'expérimentation : essayer différentes approches en parallèle sans toucher à la branche principale

Commandes de base

# Create a new worktree
git worktree add ../feature-x-worktree feature-x

# List all worktrees
git worktree list

# Remove a worktree
git worktree remove ../feature-x-worktree

# Cleanup (removes references to deleted worktrees)
git worktree prune

Agents IA et workflows parallèles

C'est là que cela devient vraiment intéressant : des agents de codage IA comme GitHub Copilot, Claude Code, Cursor ou Aider peuvent être lancés en parallèle dans des worktrees séparés. Chaque agent obtient sa propre branche et son propre dossier, isolés en toute sécurité des autres.

Scénario pratique

Exemple typique : une nouvelle fonctionnalité doit être implémentée, mais la meilleure approche n'est pas encore claire.

1. Créer plusieurs worktrees :

git worktree add ../feature-auth-v1 -b feature-auth-v1
git worktree add ../feature-auth-v2 -b feature-auth-v2
git worktree add ../feature-auth-v3 -b feature-auth-v3

2. Ouvrir chaque worktree dans une fenêtre VS Code séparée

3. Assigner un agent IA à chaque fenêtre :

Fenêtre 1 : GitHub Copilot implémente avec OAuth2
Fenêtre 2 : Claude Code tente une approche JWT
Fenêtre 3 : Cursor expérimente avec des Magic Links

4. Observer, comparer et choisir :

Les trois agents travaillent en parallèle
Les implémentations peuvent être comparées en temps réel
La meilleure solution peut être choisie, ou des aspects de plusieurs approches combinés
Toutes les branches peuvent être mergées ou les meilleurs commits cherry-pickés

Le pattern une branche par agent

Un pattern éprouvé pour utiliser des agents IA avec des worktrees :

main/
├── feature-x-agent1/    (GitHub Copilot)
├── feature-x-agent2/    (Claude Code)
└── feature-x-agent3/    (Cursor)

Chaque agent reçoit :

Son propre worktree et sa propre branche
Un environnement de travail isolé
Aucun conflit avec les autres agents
L'historique Git complet

Tests parallèles avec différentes configurations

Les worktrees sont aussi excellents pour les tests :

# Worktree for feature development
git worktree add ../feature-dev feature-branch

# Worktree for tests with mock data
git worktree add ../feature-test feature-branch

# Worktree for integration tests
git worktree add ../feature-integration feature-branch

Dans chaque worktree, il est possible de :

Définir des variables d'environnement différentes
Utiliser différentes configurations de test
Tester des services mockés versus réels
Utiliser différentes configurations de base de données

Mise à l'échelle pour les équipes, réelles ou virtuelles

Les worktrees ne sont pas réservés aux développeurs solo. Les équipes peuvent aussi les utiliser :

Plusieurs développeurs : chacun travaille dans son propre worktree
Code reviews : les reviewers peuvent checkout des PRs dans des worktrees séparés sans interrompre leur travail en cours
Hotfixes : créer rapidement un hotfix dans un worktree séparé pendant que le développement de fonctionnalités continue
Expérimentation : essayer de nouvelles approches sans impacter la branche principale

Tooling et automatisation

Les commandes Git worktree peuvent être un peu verbeuses. Voici quelques outils utiles :

Worktrunk CLI

Worktrunk est une CLI spécialement conçue pour les gros workflows avec agents IA :

# Installation
cargo install worktrunk

# Create and switch to worktree
trunk new feature-x

# Switch between worktrees
trunk switch feature-x

# Cleanup
trunk clean

Aliases personnalisés

Ajoutez ceci à votre .gitconfig :

[alias]
    wt = worktree
    wta = worktree add
    wtl = worktree list
    wtr = worktree remove
    wtp = worktree prune

Bonnes pratiques

À faire

✅ Utiliser des worktrees pour le travail parallèle : fonctionnalités, corrections, expérimentations

✅ Les combiner avec des agents IA : laisser plusieurs approches être développées en parallèle

✅ Les utiliser pour les code reviews : changement de contexte rapide sans stashing

✅ Automatiser avec des scripts : créer des wrappers pour les workflows courants

✅ Isoler les environnements de test : différentes configs dans différents worktrees

À éviter

❌ Ne pas utiliser la même branche dans plusieurs worktrees Git l'empêche déjà

❌ Ne pas oublier le cleanup : supprimer les worktrees dont on n'a plus besoin

❌ Ne pas ignorer .env et les configs : ils ne sont pas synchronisés automatiquement

❌ Ne pas en faire trop : trop de worktrees deviennent difficiles à gérer

Exemple pratique : développer une fonctionnalité avec trois agents IA

Voici un exemple concret :

# 1. Prepare main repository
cd ~/projects/my-app
git checkout main
git pull

# 2. Create three worktrees for three agents
git worktree add ../my-app-copilot -b feature/user-auth-copilot
git worktree add ../my-app-claude -b feature/user-auth-claude
git worktree add ../my-app-cursor -b feature/user-auth-cursor

# 3. Open VS Code windows
code ../my-app-copilot
code ../my-app-claude
code ../my-app-cursor

# 4. In each window, activate the respective AI agent
# and begin implementation

# 5. Compare after development
cd ~/projects/my-app
git diff feature/user-auth-copilot feature/user-auth-claude
git diff feature/user-auth-claude feature/user-auth-cursor

# 6. Merge best approach or cherry-pick commits
git checkout main
git merge feature/user-auth-copilot  # or the best one

# 7. Cleanup
git worktree remove ../my-app-copilot
git worktree remove ../my-app-claude
git worktree remove ../my-app-cursor
git branch -d feature/user-auth-copilot feature/user-auth-claude feature/user-auth-cursor

Transformer le caractère non déterministe des LLM en avantage

Aspect intéressant : les agents IA sont non déterministes, le même prompt peut produire des solutions différentes. Avec les worktrees, cela devient un avantage :

Créez N worktrees pour la même fonctionnalité
Faites travailler N agents IA en parallèle
Comparez toutes les implémentations
Sélectionnez la meilleure ou combinez leurs forces

C'est comme une code review avec plusieurs développeurs, mais en une fraction du temps.

Performance et stockage

Une idée reçue fréquente : "Plusieurs worktrees = plus de stockage consommé"

Faux ! Les worktrees partagent l'historique .git :

# One clone
du -sh my-app/.git     # 150 MB

# Three worktrees
du -sh my-app/.git     # 150 MB (same!)
du -sh my-app-wt1      # 50 MB (working copy only)
du -sh my-app-wt2      # 50 MB (working copy only)
du -sh my-app-wt3      # 50 MB (working copy only)
# Total: 300 MB

# Three clones would require 450 MB (3 × 150 MB)

Conclusion

Git Worktrees est un game changer pour le développement moderne, en particulier lorsqu'il est combiné à des agents de codage IA. Il permet :

Un vrai parallélisme sans surcharge
Une utilisation efficace des agents IA pour développer plus vite
Une expérimentation sans risque avec différentes approches
Une productivité améliorée grâce à moins de context switching

Dans un monde où les agents IA deviennent de plus en plus autonomes et prennent en charge des projets plus vastes, maîtriser les worktrees devient une compétence précieuse. Chez vensas, nous utilisons régulièrement cette technique pour transformer nos machines de développement en équipes virtuelles, où nous pouvons poursuivre plusieurs approches en parallèle, les comparer et retenir les meilleures solutions.

Ressources complémentaires

Besoin d'aide ?

Vous voulez introduire Git Worktrees et des agents IA dans votre équipe de développement, mais vous ne savez pas comment optimiser vos workflows ? Nous pouvons vous aider. Contactez-nous via notre page de contact et nous préparerons ensemble votre équipe aux pratiques de développement modernes.

Avez-vous déjà de l'expérience avec Git Worktrees ? Ou utilisez-vous d'autres stratégies pour le développement parallèle ? Chez vensas, nous serons ravis de recevoir vos retours et d'échanger des bonnes pratiques.

Développer à l'échelle avec Git Worktrees et des agents IA