Gérer plusieurs sessions Claude Code : astuces d'utilisateur avancé

Une session Claude Code est utile. Plusieurs sessions en parallèle, c'est là que le multiplicateur de productivité entre en jeu.

Vous pouvez avoir Claude qui corrige des tests dans un projet, refactorise du code dans un autre et écrit de la documentation dans un troisième — le tout tournant simultanément sur votre Mac pendant que vous surveillez depuis votre téléphone. La clé est de les gérer sans perdre le contexte ni envoyer accidentellement la mauvaise commande à la mauvaise session.

Comment les sessions fonctionnent en interne

Chaque session Claude Code dans Tactic Remote tourne dans une session tmux sur votre Mac. tmux gère l'isolation des processus :

# Each session is a separate tmux session
tmux list-sessions
# my-api: 1 windows (created Sat Feb 28 14:30:01 2026)
# frontend: 1 windows (created Sat Feb 28 14:45:12 2026)
# docs-site: 1 windows (created Sat Feb 28 15:00:00 2026)

Chaque session a son propre :

• Répertoire de travail (chemin du projet)
• Instance Claude Code avec son propre contexte de conversation
• Buffer de défilement (50 000 lignes par défaut)
• Flux d'entrée/sortie indépendant

Quand vous basculez entre sessions sur votre iPhone, le serveur se détache d'une session tmux et s'attache à une autre. La session que vous quittez continue de tourner — Claude Code ne s'arrête pas parce que vous avez basculé.

Configurer des sessions parallèles

Stratégie de nommage

Les noms de session sont auto-générés depuis le nom du dossier du projet. Pour un répertoire /Users/you/code/my-api, le nom de session devient my-api. Cela fonctionne bien jusqu'à ce que vous ayez plusieurs projets avec des noms similaires.

Conseils :

• Utilisez des noms de dossier de projet distincts
• Si vous travaillez sur des branches du même projet, incluez le contexte de branche dans votre prompt plutôt que de créer des sessions séparées
• Gardez les noms de session courts — vous les verrez dans une liste sur votre téléphone

Sélection du chemin de projet

En créant une session, vous parcourez le système de fichiers de votre Mac depuis votre téléphone. Tactic Remote affiche :

• Les chemins récemment utilisés (jusqu'à 10, les plus récents en premier)
• Les chemins favoris que vous avez épinglés
• Un navigateur de répertoires complet pour naviguer vers de nouveaux emplacements

Pour gagner en rapidité, configurez vos répertoires de projet les plus utilisés comme favoris avant d'en avoir besoin. Parcourir des répertoires profondément imbriqués sur un téléphone est fastidieux.

Le workflow parallèle

Voici un exemple concret de gestion de trois sessions parallèles :

Session 1 : Correction de bug API

Project: /Users/you/code/billing-api
Task: "The webhook handler is dropping events when multiple arrive simultaneously.
       Add a queue with retry logic."
Status: Claude is working autonomously

Session 2 : Fonctionnalité frontend

Project: /Users/you/code/dashboard-ui
Task: "Add a dark mode toggle to the settings page.
       Use the existing theme context."
Status: Claude is waiting for approval (wants to install a new dependency)

Session 3 : Documentation

Project: /Users/you/code/docs-site
Task: "Update the API reference for the billing endpoints
       to reflect the new webhook queue behavior."
Status: Idle (waiting for Session 1 to finish so docs match the code)

Votre téléphone affiche la liste des sessions. Vous voyez que la Session 2 nécessite votre attention (demande d'approbation). Tapez pour basculer, examinez la dépendance que Claude veut ajouter, tapez Y ou N, rebasculez vers le monitoring.

Patterns de gestion de sessions

Pattern 1 : Dépendances en pipeline

Parfois les sessions ont des dépendances logiques : terminer le changement API, puis mettre à jour le frontend, puis mettre à jour la documentation.

Approche :

1. Démarrez la Session 1 (API) avec la tâche principale
2. Soyez notifié quand la Session 1 se termine
3. Examinez les changements de la Session 1
4. Démarrez la Session 3 (docs) en référençant les changements API terminés
5. Pendant ce temps, la Session 2 (frontend) peut tourner indépendamment

L'essentiel : ne démarrez pas les tâches dépendantes avant que la tâche amont soit terminée. Claude Code ne connaît pas vos autres sessions — chacune opère indépendamment.

Pattern 2 : Tâches parallèles indépendantes

Quand les tâches sont vraiment indépendantes, démarrez-les toutes en même temps :

1. Créez la Session 1, envoyez la tâche
2. Créez la Session 2, envoyez la tâche
3. Créez la Session 3, envoyez la tâche
4. Attendez les notifications

Cela maximise le débit. Votre Mac gère l'exécution parallèle (chaque instance Claude Code est un processus séparé). Surveillez la liste des sessions pour voir lesquelles tournent encore.

Pattern 3 : Exploration + Production

Utilisez une session pour l'exploration et une autre pour le travail de production :

• Session d'exploration : "Lis le module de paiement et explique l'architecture. Liste les classes principales et leurs responsabilités."
• Session de travail : (après lecture de la sortie d'exploration) "Refactorise PaymentProcessor pour extraire la logique de validation dans une classe ValidationService séparée."

Cela empêche votre session de travail de se remplir de contexte exploratoire qui dilue la concentration de Claude.

Conseils pratiques

Gardez les sessions focalisées

Chaque session devrait avoir un objectif clair. Évitez la tentation de réutiliser une session qui a terminé une tâche pour quelque chose de complètement différent — le contexte de conversation accumulé de la tâche précédente peut perturber Claude sur la nouvelle.

Plutôt : créez une nouvelle session pour chaque tâche distincte. Les sessions sont peu coûteuses (ce sont juste des sessions tmux).

Utilisez /compact pour les longues sessions

Si une session tourne depuis un moment avec beaucoup d'allers-retours, le contexte de conversation grossit. Cela peut ralentir Claude et augmenter les coûts en tokens. La commande slash /compact condense la conversation, gardant le contexte important tout en réduisant le nombre de tokens.

Surveillez les coûts avec /cost

Quand vous exécutez plusieurs sessions en parallèle, les coûts en tokens se multiplient. Utilisez la commande /cost dans chaque session pour vérifier les dépenses. Une bonne habitude : vérifier /cost dans chaque session active en fin de journée.

Supprimez les sessions terminées

Les sessions tmux inactives consomment des ressources minimales, mais elles encombrent votre liste de sessions. Après avoir examiné la sortie d'une tâche terminée, supprimez la session si vous n'avez pas besoin de la consulter à nouveau.

Utilisez les snippets pour les opérations répétées

Si vous exécutez fréquemment les mêmes commandes dans chaque session (ex : "Lancer les tests", "Vérifier le statut git"), sauvegardez-les comme snippets personnalisés. Un tap au lieu de taper à chaque fois.

Les snippets intégrés couvrent déjà les patterns courants :

• Catégorie Claude : Démarrer session, condenser, vérifier le coût
• Catégorie Git : Status, commit, push
• Catégorie Système : Lister fichiers, vérifier le disque

Considérations de ressources

Exécuter plusieurs instances Claude Code en parallèle consomme :

• CPU et mémoire sur votre Mac — chaque processus Claude Code et session tmux utilise des ressources. Les Macs modernes gèrent confortablement 3-5 sessions concurrentes. Au-delà, vérifiez le Moniteur d'activité.
• Tokens API — la conversation de chaque session avec le modèle IA coûte des tokens. Les sessions parallèles multiplient cela linéairement.
• Bande passante réseau — minimale. Le texte terminal est petit comparé à la vidéo ou aux gros transferts de fichiers.

L'app Mac empêche la veille tant que le serveur tourne, ce qui est important pour les longues sessions parallèles. Mais surveillez la température et la batterie de votre Mac (si sur portable) quand vous exécutez beaucoup de sessions simultanément.

Basculer entre contextes sans perdre votre position

Quand vous basculez de la Session A à la Session B sur votre téléphone :

• La Session A continue de tourner (Claude continue de travailler)
• La dernière sortie de la Session B se charge avec restauration d'état
• Votre téléphone affiche le terminal de la Session B depuis la position la plus récente

Quand vous rebasculez vers la Session A :

• La Session B continue de tourner
• La sortie de la Session A se recharge, montrant tout progrès fait par Claude pendant votre absence

La restauration multi-étapes (intervalles de rafraîchissement à 0.2s, 0.7s, 1.5s) assure que vous obtenez l'état courant complet même si le chargement initial est partiel.

Anti-patterns à éviter

Ne micro-gérez pas les sessions parallèles. Si vous basculez constamment entre sessions pour vérifier la progression, vous ne gagnez pas en productivité. Faites confiance au système de notifications — il vous dit quand quelque chose nécessite votre attention.

N'utilisez pas une seule session pour tout. Une session unique qui exécute tâche après tâche accumule du contexte qui finit par dégrader les performances. Créez des sessions fraîches pour les tâches distinctes.

Ne laissez pas trop de sessions inactives. Bien qu'elles utilisent des ressources minimales, une longue liste de sessions sur votre téléphone rend plus difficile de trouver les sessions actives. Faites le ménage après vous.

Ne démarrez pas les tâches dépendantes prématurément. Si la Session 2 dépend de la sortie de la Session 1, attendez que la Session 1 soit terminée. Démarrer la Session 2 tôt avec des hypothèses sur ce que la Session 1 produira mène à du travail gaspillé.