Coder depuis la plage : de GitHub Codespaces à Codex CLI sur ma seedbox

Publié le 14 août 2026

Cet été, je voulais continuer à faire avancer quelques-uns de mes projets sans pour autant partir en vacances avec mon PC portable sous le bras.

L’idée n’était surtout pas de coder sur un iPhone. Rien que d’y penser, ça ne donne pas particulièrement envie.

Mon objectif était différent : utiliser l’iPhone comme une télécommande pour Codex.

Ouvrir un terminal, donner un objectif à Codex, fermer le téléphone et le laisser travailler tranquillement pendant quelques heures. Puis revenir plus tard voir le résultat, apporter quelques précisions et éventuellement lui donner une nouvelle tâche.

C’est comme ça que je me suis retrouvé à lancer des /goal depuis la plage de Palma avant de remettre tranquillement mon téléphone dans le sac.

Pour arriver à ce résultat, je suis d’abord passé par GitHub Codespaces, puis ShellFish sur iOS, avant de finalement réaliser que j’avais déjà une solution encore mieux adaptée : ma seedbox, SSH et tmux.

Première expérimentation : GitHub Codespaces

Sur le papier, GitHub Codespaces répond parfaitement au besoin.

À partir d’un dépôt GitHub, on obtient en quelques instants une véritable machine de développement dans le cloud :

• le dépôt Git est disponible ;
• on dispose d’un terminal Linux ;
• Node.js et les différents outils du projet peuvent être installés ;
• Codex CLI peut fonctionner comme sur une machine classique ;
• l’environnement est accessible depuis Internet.

Pour travailler ponctuellement sans avoir son ordinateur avec soi, c’est assez bluffant.

Une fois connecté au Codespace, je pouvais simplement lancer :

codex

Puis confier une tâche relativement autonome à Codex avec un /goal.

Et c’est précisément là que le fonctionnement devient intéressant.

Codex n’a pas besoin que je reste devant le terminal pendant qu’il travaille. Il peut analyser le projet, parcourir les fichiers, écrire du code, lancer des commandes, exécuter des tests et corriger ses erreurs.

L’iPhone ne sert donc pas réellement à développer.

Il sert à dire à Codex quoi développer.

ShellFish : le terminal qu’il me fallait sur iPhone

Restait néanmoins un problème : comment accéder confortablement à cet environnement depuis un iPhone ?

Passer systématiquement par une interface web n’était pas particulièrement agréable. Je voulais quelque chose de beaucoup plus direct : ouvrir une application et me retrouver immédiatement dans mon terminal.

J’ai finalement retenu ShellFish, une application iOS permettant notamment d’utiliser SSH et SFTP.

Et pour mon besoin, c’était exactement ce qu’il fallait.

Le fonctionnement était alors très simple :

iPhone
   │
ShellFish
   │
   │ SSH
   ▼
GitHub Codespace
   │
   ├── Git
   ├── projet
   └── Codex CLI

J’ouvrais ShellFish, je me connectais à mon environnement distant et je retrouvais un véritable terminal.

Quelques commandes suffisaient alors pour me placer dans le projet et lancer Codex :

cd mon-projet
codex

Je pouvais ensuite écrire mon /goal, vérifier que Codex était correctement parti sur sa tâche et ranger le téléphone.

C’était beaucoup plus proche de l’expérience que je recherchais.

Le téléphone devient une télécommande

Ce changement de perspective est finalement assez important.

Essayer de reproduire un environnement VS Code complet sur un écran de téléphone n’a que peu d’intérêt pour moi. L’écran est trop petit, le clavier virtuel devient rapidement pénible et naviguer entre plusieurs fichiers n’est pas agréable.

Avec un agent comme Codex, ce n’est plus réellement nécessaire.

Mon workflow ressemblait plutôt à ça :

Ouvrir ShellFish
       ↓
Connexion SSH
       ↓
Reprendre Codex
       ↓
Donner un /goal
       ↓
Vérifier le démarrage
       ↓
Fermer ShellFish
       ↓
Profiter des vacances

Quelques heures plus tard, je pouvais revenir voir le résultat.

C’est une manière assez différente d’envisager le développement à distance.

Depuis la plage de Palma

Et c’est pendant nos vacances à Majorque que cette expérimentation a réellement pris son sens.

Pas besoin de sortir un ordinateur portable ni de chercher une table et une prise électrique.

Depuis la plage de Palma, je pouvais sortir l’iPhone, ouvrir ShellFish, me connecter à mon environnement et donner une nouvelle tâche à Codex.

Quelques minutes plus tard, le téléphone retournait dans le sac.

Codex, lui, pouvait continuer son travail.

C’est assez amusant la première fois que l’on réalise qu’une tâche de développement relativement conséquente est en train de s’exécuter quelque part pendant que l’on est tranquillement sur une plage à plusieurs milliers de kilomètres.

Mais cette utilisation m’a aussi permis de mettre en évidence les limites de mon architecture.

La limite de Codespaces

GitHub Codespaces est excellent pour créer rapidement un environnement de développement.

Mais un Codespace reste, par conception, une ressource temporaire.

Il peut notamment être arrêté après une période d’inactivité. Ce comportement est parfaitement logique pour éviter de laisser tourner inutilement des machines dans le cloud.

Pour mon utilisation de Codex, en revanche, je recherchais presque exactement l’inverse.

Je voulais quelque chose comme :

10h00  → lancement d'un /goal

10h05  → téléphone dans le sac
         Codex continue à travailler

12h00  → reconnexion
         vérification du résultat

12h10  → nouveau /goal

17h00  → reprise de la session

Je voulais donc un environnement permanent, mais également une session de terminal persistante.

Et c’est là que tmux devient particulièrement intéressant.

tmux : la pièce manquante

tmux est ce que l’on appelle un multiplexeur de terminal.

Son fonctionnement peut paraître un peu obscur au premier abord, mais pour mon utilisation une seule de ses fonctions est réellement importante :

une session tmux continue d’exister même lorsque je ferme ma connexion SSH.

Je peux créer une session :

tmux new -s codex

Puis lancer Codex à l’intérieur :

codex

Je donne ensuite un /goal à Codex.

Une fois la tâche lancée, je détache la session avec :

Ctrl+B puis D

Je peux maintenant fermer complètement ShellFish.

La connexion SSH est coupée.

Mais sur la machine distante :

tmux
  │
  └── Codex
        │
        └── /goal en cours

continue tranquillement à fonctionner.

Quelques heures plus tard, je me reconnecte en SSH et je tape :

tmux attach -t codex

Et je retrouve exactement le même terminal, avec la même session Codex.

C’est précisément ce qu’il me fallait.

Et si je remplaçais Codespaces ?

À ce stade, une question assez évidente s’est posée.

Pourquoi utiliser une machine Codespaces alors que je disposais déjà d’une machine Linux accessible en permanence ?

J’utilise une seedbox, allumée 24 heures sur 24 et accessible à distance en SSH.

Elle disposait déjà d’une bonne partie de ce dont j’avais besoin et pouvait devenir mon environnement Codex permanent.

Il suffisait finalement d’y disposer de :

• Git ;
• mes dépôts ;
• Codex CLI ;
• tmux ;
• SSH.

L’architecture devenait alors :

                    GitHub
                      ▲
                      │
                   git push
                      │
                      │
iPhone ── ShellFish ──SSH──► Seedbox
                              │
                              ├── projets Git
                              │
                              └── tmux
                                   │
                                   └── Codex CLI
                                         │
                                         └── /goal

Plus besoin de créer ou démarrer un Codespace.

Ma machine de développement distante était déjà allumée en permanence.

Une session par projet

Avec tmux, je peux également organiser les sessions en fonction des projets.

Par exemple :

tmux new -s zod

pour un projet, puis :

tmux new -s smb

pour un autre.

La commande suivante permet de voir les sessions disponibles :

tmux ls

Ce qui peut donner quelque chose comme :

zod: 1 windows
smb: 1 windows
blog: 1 windows

Depuis ShellFish, je peux alors choisir celle que je veux reprendre :

tmux attach -t zod

Je retrouve immédiatement Codex et son contexte de travail.

Puis je détache à nouveau :

Ctrl+B puis D

Et la session continue à vivre sans mon téléphone.

ShellFish + SSH + tmux + Codex

C’est finalement cette combinaison qui répond réellement à mon besoin :

        iPhone
           │
       ShellFish
           │
          SSH
           │
        Seedbox
           │
         tmux
           │
      Codex CLI
           │
         /goal

Chaque élément a un rôle très simple.

ShellFish me donne un terminal confortable sur l’iPhone.

SSH me permet d’accéder à la machine distante.

tmux rend mes sessions indépendantes de la connexion SSH.

Codex CLI effectue le travail.

GitHub reste le point central où je pousse ensuite les modifications.

L’ensemble est finalement beaucoup plus simple qu’un environnement de développement distant traditionnel.

Codespaces n’était pas une mauvaise piste

Pour autant, je ne considère pas mon expérimentation avec GitHub Codespaces comme inutile.

Au contraire.

Codespaces m’a permis de valider le concept sans avoir à préparer une infrastructure particulière.

J’ai pu vérifier qu’il était réellement possible de :

• piloter Codex depuis un téléphone ;
• travailler correctement avec un simple terminal SSH ;
• lancer des tâches relativement longues ;
• quitter son téléphone pendant leur exécution ;
• revenir plus tard contrôler le résultat.

C’était finalement une preuve de concept.

Une fois celle-ci validée, la seedbox s’est simplement révélée plus adaptée à mon usage permanent.

Les commandes à retenir

Au final, le nombre de commandes nécessaires est assez réduit.

Lancer Codex

codex

Créer une session tmux

tmux new -s codex

Ou en utilisant le nom du projet :

tmux new -s zod

Détacher une session

Depuis une session tmux :

Ctrl+B puis D

Codex continue alors à fonctionner.

Afficher les sessions existantes

tmux ls

Reprendre une session

tmux attach -t codex

Ou :

tmux attach -t zod

Vérifier les modifications effectuées par Codex

git status

Ajouter toutes les modifications

git add .

Créer le commit

git commit -m "Description des modifications"

Envoyer les modifications sur GitHub

git push

Si la branche distante n’existe pas encore :

git push -u origin nom-de-la-branche

Le workflow Git complet après le travail de Codex tient donc finalement en quatre commandes :

git status
git add .
git commit -m "Description des modifications"
git push

Conclusion

Cette expérimentation est partie d’une contrainte toute simple : je ne voulais pas emmener mon PC portable partout pendant les vacances.

GitHub Codespaces m’a d’abord fourni une machine de développement disponible à la demande.

ShellFish m’a ensuite permis de transformer mon iPhone en terminal SSH réellement utilisable.

Puis tmux a résolu le problème essentiel de la persistance : une tâche Codex pouvait continuer à tourner même après avoir fermé ShellFish et perdu la connexion SSH.

À partir de là, Codespaces n’était finalement plus indispensable. Ma seedbox pouvait assurer exactement ce rôle, avec l’avantage d’être déjà disponible 24 heures sur 24.

Ce que je retiens surtout de cette expérience, c’est que l’arrivée d’agents comme Codex modifie assez profondément la notion de développement à distance.

Je n’ai plus forcément besoin d’avoir mon IDE devant moi.

Je n’ai même plus forcément besoin de rester connecté.

Je peux simplement ouvrir ShellFish, reprendre une session tmux, donner un /goal à Codex et revenir quelques heures plus tard.

Et lorsque l’on peut faire tout ça en quelques minutes depuis la plage de Palma avant de remettre son téléphone dans le sac, on commence vraiment à comprendre l’intérêt des agents de développement autonomes.