Mon workflow quotidien avec Tactic Remote : sessions, notifications et boucle de revue mobile

Je fais tourner Claude Code sur trois projets simultanément. Chacun travaille sur une tâche différente — frontend, backend, tests. Quand l'un d'eux termine ou a besoin de mon approbation, je reçois une notification push sur mon téléphone. Je tape, je revois, j'approuve, et je repars.

C'est mon workflow quotidien réel avec Tactic Remote. Pas de théorie. Juste ce que je fais chaque jour.

En bref : Trois sessions tmux, une par projet ou tâche. Les hooks auto-configurés par l'app Mac compagnon envoient des notifications push. Revoyez depuis votre iPhone, approuvez d'un tap, continuez à marcher.

L'organisation des sessions

J'organise les sessions tmux par projet, pas par outil. Chaque projet a sa propre session avec son propre répertoire de travail :

┌─────────────────────────────────────────────────┐
│                  Votre Mac                       │
│                                                  │
│  session tmux : webapp      (~/code/webapp)      │
│    └─ Claude : "Refactoring auth pour JWT..."    │
│                                                  │
│  session tmux : api         (~/code/api)         │
│    └─ Claude : "Ajout du rate limiting..."       │
│                                                  │
│  session tmux : mobile      (~/code/mobile-app)  │
│    └─ Claude : "Correction crash navigation..."  │
│                                                  │
└─────────────────────────────────────────────────┘
                      │
                      │  notification push :
                      │  "Tâche Claude terminée — webapp"
                      ▼
              ┌──────────────┐
              │   iPhone     │
              │  Claude      │
              │  Remote      │
              └──────────────┘

Pourquoi des sessions plutôt que des fenêtres ? Parce que chaque instance de Claude Code a besoin de son propre répertoire de travail et de son propre buffer de scrollback de 50 000 lignes. Les sessions offrent une isolation propre — basculer entre projets, c'est basculer entre sessions, pas se souvenir quel numéro de fenêtre correspond à quelle tâche.

Créer des sessions depuis votre téléphone

Depuis l'app Tactic Remote :

1. Tapez sur le sélecteur de session (haut de l'écran)
2. Tapez sur « Créer une session »
3. Nommez-la (par ex., webapp)
4. Naviguez vers le répertoire du projet avec le sélecteur de chemin
5. Tapez sur « Démarrer Claude »

En coulisses, cela déclenche :

tmux new-session -d -s webapp -c ~/code/webapp
tmux set-option -t webapp history-limit 50000
tmux send-keys -t webapp -l 'claude'
tmux send-keys -t webapp C-m

Puis répétez pour api et mobile. Trois sessions, trois instances Claude Code indépendantes, chacune limitée au bon projet.

Le pipeline de notifications

C'est la partie qui rend tout le workflow praticable. Sans notifications, il faudrait vérifier constamment votre téléphone pour voir si Claude a terminé. Avec elles, vous pouvez vraiment partir.

Comment c'est configuré

L'app Mac compagnon auto-configure les hooks Claude Code au démarrage du serveur. Aucune configuration manuelle nécessaire. Elle écrit trois scripts shell dans ~/.claude/hooks/ :

#!/bin/bash
# claude-remote-stop.sh (auto-généré)
 
PORT="${CLAUDE_REMOTE_PORT:-8765}"
HOOK_SERVER_URL="http://localhost:${PORT}/hook"
 
TMUX_SESSION=""
if [ -n "$TMUX" ]; then
    TMUX_SESSION=$(tmux display-message -p '#S')
fi
 
PROJECT="$(basename "$PWD")"
TIMESTAMP=$(date +%s)
 
curl -s -X POST "$HOOK_SERVER_URL" \
    -H "Content-Type: application/json" \
    -d "{\"event\":\"Stop\",\"project\":\"$PROJECT\",\"tmux_session\":\"$TMUX_SESSION\",\"timestamp\":$TIMESTAMP}" \
    > /dev/null 2>&1 &
exit 0

Puis elle enregistre ces scripts dans ~/.claude/settings.json pour que Claude Code les appelle sur les événements du cycle de vie :

{
  "hooks": {
    "Stop": [
      {
        "matcher": "*",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/claude-remote-stop.sh" }]
      }
    ],
    "Notification": [
      {
        "matcher": "*",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/claude-remote-notification.sh" }]
      }
    ]
  }
}

Le flux d'événements

Claude termine une tâche
    │
    ▼
Le hook Claude Code se déclenche : claude-remote-stop.sh
    │
    ▼
curl POST http://localhost:8765/hook
  {"event": "Stop", "project": "webapp", "tmux_session": "webapp"}
    │
    ▼
Le serveur Node.js reçoit le hook → diffuse à tous les clients WebSocket
    │
    ├─► Si l'iPhone est au premier plan :
    │     Le terminal affiche : 📢 [Claude] Projet terminé
    │
    └─► Si l'iPhone est en arrière-plan :
          La notification système apparaît
          Tapez → ouvre directement dans la session

Déduplication

Claude déclenche parfois plusieurs événements de hook en succession rapide — par exemple, quand il termine plusieurs sous-tâches d'affilée. L'app iOS déduplique avec une fenêtre de 3 secondes. Si le même événement (même projet, même session, même timestamp) arrive deux fois dans les 3 secondes, le doublon est silencieusement ignoré. Pas de spam de notifications.

La boucle de revue

Voici à quoi ressemble un cycle de revue typique :

Étape 1 : Recevoir la notification

Mon téléphone vibre : « Tâche Claude terminée — webapp »

Je suis dans un café, sur le canapé ou en train de marcher vers le déjeuner. Peu importe.

Étape 2 : Examiner la sortie

Tapez sur la notification. Tactic Remote ouvre directement dans la session webapp. Je vois la sortie complète de Claude — ce qu'il a changé, ce qu'il demande, les résultats de tests.

La vue terminal préserve tout le formatage de Claude Code : coloration syntaxique, couleurs de diff, caractères de dessin de boîte pour son UI. Ce n'est pas un résumé simplifié — c'est la vraie sortie terminal, rendue avec les couleurs ANSI sur votre téléphone.

Si la sortie est longue, faites défiler vers le haut. Le buffer de scrollback tmux de 50 000 lignes signifie que rien n'est perdu, même si Claude a produit des pages de sortie pendant votre absence. L'app peut récupérer jusqu'à 5 000 lignes avec « Charger plus ».

Étape 3 : Approuver ou rediriger

Trois scénarios courants :

Claude attend la permission d'exécuter une commande :

Claude affiche quelque chose comme :

> Need permission to run: npm install bcrypt
> [y/n]

Je tape sur le bouton Y de la barre d'outils du clavier. Un tap. Claude continue.

Claude a terminé et est à son prompt :

Je tape une nouvelle instruction : « Maintenant écris des tests pour le module auth. » J'appuie sur envoyer. Claude commence à travailler sur la tâche suivante. Je range mon téléphone.

Claude a rencontré une erreur et a besoin de conseils :

Je lis l'erreur, tape une réponse expliquant quoi faire différemment, et j'envoie. Claude ajuste son approche.

Étape 4 : Repartir

Après avoir approuvé ou redirigé, je bascule vers la session suivante (tape sur le sélecteur de session, tape sur api) pour vérifier l'autre tâche. Si elle est encore en cours, je repars et attends la prochaine notification.

La boucle est : notification → revue → action → repartir. Chaque cycle prend 30 secondes à 2 minutes, selon ce que Claude a produit.

Stratégie de tâches parallèles

Faire tourner plusieurs instances Claude en parallèle est puissant mais demande de la discipline. Voici ce que j'ai appris :

Donnez à chaque tâche un brief clair et complet

N'envoyez pas d'instructions vagues comme « travaille sur le frontend ». Envoyez des instructions spécifiques :

Refactorise le module d'authentification dans src/auth/ pour utiliser
des tokens JWT au lieu de cookies de session. Mets à jour tous les
handlers de route qui vérifient l'auth. Écris des tests. Lance la
suite de tests existante pour vérifier que rien ne casse.

Plus votre prompt est spécifique, plus Claude peut travailler de manière autonome avant de demander une saisie. Les prompts vagues signifient plus d'interruptions.

Échelonnez vos démarrages

Ne démarrez pas les trois sessions exactement en même temps. Démarrez-en une, attendez qu'elle commence à travailler (vous verrez la sortie initiale en environ 5 secondes), puis démarrez la suivante. Cela évite que les trois atteignent des invites de permission simultanément, ce qui signifierait trois notifications arrivant en même temps.

Vérifiez celle qui tourne depuis le plus longtemps en dernier

Lors de la revue, commencez par la session qui tourne depuis le plus longtemps — c'est celle qui a le plus de chances d'être terminée ou bloquée. La session la plus récemment démarrée est probablement encore en train de travailler.

Utilisez des noms de session qui ont du sens

Quand vous recevez une notification push qui dit « Tâche Claude terminée — webapp », vous devez savoir ce que ça signifie sans réfléchir. Ne nommez pas les sessions session1, session2, session3. Nommez-les d'après les projets ou les tâches.

Actions rapides que j'utilise constamment

La barre d'outils du clavier en bas de la vue de chat a des touches spéciales conçues pour l'interaction avec Claude Code :

Les boutons Y et N existent spécifiquement parce que les invites de permission de Claude Code sont l'interaction la plus courante. Pouvoir approuver d'un seul tap — pas en tapant « y » sur un clavier de téléphone — rend le workflow mobile praticable.

Mon .tmux.conf

Minimal. Je ne fais rien d'extravagant :

# Grand scrollback — Claude produit BEAUCOUP de sortie
set -g history-limit 50000
 
# Défilement souris (peu utilisé depuis le téléphone, mais utile au bureau)
set -g mouse on
 
# Commencer la numérotation des fenêtres à 1
set -g base-index 1

Tactic Remote définit le scrollback à 50 000 lors de la création des sessions, donc le paramètre .tmux.conf est un filet de sécurité pour les sessions créées manuellement.

Ce que ça donne en pratique

Une matinée typique :

8h00 — Je m'assieds à mon Mac. Trois projets ont besoin de travail. Je crée trois sessions depuis l'app Mac compagnon (ou depuis l'iPhone — les deux fonctionnent).

8h05 — J'envoie à Claude une tâche détaillée dans chaque session. Direction la cuisine.

8h20 — Première notification : la session api est terminée. Revue sur iPhone. Claude a ajouté le rate limiting, les tests passent. J'envoie la tâche suivante : « Maintenant ajoute les en-têtes de rate limit à la doc API. »

8h35 — Deuxième notification : la session webapp a besoin d'approbation. J'ouvre. Claude veut installer une nouvelle dépendance. Je vérifie que ça semble correct. Je tape Y. Direction mon bureau.

8h50 — Troisième notification : la session mobile est terminée. Revue. C'est bon. Je lance une nouvelle tâche.

9h00 — Je m'assieds à mon Mac. Les trois projets ont fait des progrès significatifs. Je revois les diffs dans git, commite, pousse.

Une heure, trois projets, la majorité faite pendant que je préparais le café et prenais mon petit-déjeuner. La boucle de revue mobile signifie que Claude n'a jamais été bloqué en attendant que je sois à mon bureau.

Conseils

Activez les notifications immédiatement. Les hooks sont auto-configurés par l'app Mac compagnon, mais vous devez accorder les permissions de notification sur votre iPhone quand demandé. Faites-le au premier lancement — tout le workflow en dépend.

Gardez Tactic Remote dans votre dock. Vous l'ouvrirez 20-30 fois par jour pendant les sessions de développement actives. L'avoir à un tap de distance compte.

Faites confiance au scrollback. Quand vous vous reconnectez à une session, toute la sortie est là. Pas besoin de demander à Claude « qu'as-tu fait ? » — faites défiler vers le haut et lisez la sortie terminal directement.

Ne micro-gérez pas. Le but de ce workflow est de donner à Claude des tâches substantielles et de partir. Si vous vérifiez toutes les 2 minutes, vous l'utilisez mal. Donnez-lui une tâche de 15 minutes, attendez la notification, puis revoyez.

Pour les détails techniques du fonctionnement du serveur, de tmux et des notifications, consultez Exécuter Claude Code à distance depuis votre téléphone. Pour la configuration initiale, consultez Démarrage rapide.