GSD-2 : l'agent IA autonome qui construit du logiciel pendant que vous dormez

Le premier framework Get Shit Done a explose parce qu’il attaquait un probleme reel : les longues sessions d’IA de generation de code finissent souvent par se degrader. Le contexte se remplit, le modele oublie les bons choix, reintroduit des erreurs et perd en nettete.

GSD-2 pousse cette logique beaucoup plus loin. Ce n’est plus seulement un cadre de prompts. C’est un vrai CLI autonome qui orchestre les taches, isole le contexte, gere l’avancement, surveille les couts et peut faire avancer un milestone entier sans intervention humaine constante.

En clair : on passe d’un “bon mode d’emploi pour Claude Code” a une couche d’orchestration agentique complete.

Pourquoi la pourriture de contexte detruit la qualite

Dans une longue session unique, le modele doit continuer a porter :

• les anciennes decisions d’architecture
• les essais rates
• les logs
• les branches d’idee abandonnees
• les fragments de code temporaires

Cette accumulation cree ce que beaucoup appellent context rot. GSD-2 combat cela en reconstruisant un contexte propre pour chaque tache.

L’architecture mentale de GSD-2

Le travail est organise en trois niveaux :

• Project
• Milestone
• Slice
• Task

Chaque tache doit rester suffisamment petite pour tenir dans une fenetre de contexte bien delimitee. C’est ce principe qui maintient la qualite.

Le cycle typique :

1. planifier
2. executer
3. completer
4. reassesser

Prerequis

Pour un setup Ubuntu/Linux classique :

• Ubuntu 20.04+
• Node.js 20+
• npm correctement configure
• acces a Claude ou a un autre fournisseur compatible
• Git initialise dans le projet

Etape 1 : installer GSD-2

npm install -g gsd-pi@latest

Si npm pose un probleme de permissions, il faut configurer un prefixe global utilisateur, puis reessayer.

Une fois installe :

gsd --version

Etape 2 : connexion et choix du fournisseur

GSD-2 supporte plusieurs fournisseurs, mais Claude est un choix naturel pour les workflows de code autonomes.

Le flux general :

gsd
/login

Puis verification avec :

/gsd status

Etape 3 : initialiser un projet

On se place dans le depot cible puis on initialise :

mkdir my-project && cd my-project
git init

GSD-2 prepare alors son environnement de travail et sa logique d’orchestration autour du projet.

Etape 4 : lancer GSD-2

Deux modes sont surtout a retenir :

Step mode

Vous validez les phases une par une. C’est le meilleur mode pour apprendre le fonctionnement ou pour des projets sensibles.

Auto mode

Vous laissez GSD-2 avancer seul sur le milestone. C’est le mode qui rend l’outil vraiment different d’un simple assistant interactif.

Il existe aussi des commandes pour suivre l’avancement sans interrompre le travail.

Etape 5 : dashboard et suivi

Le tableau de bord permet de voir :

• l’etat du milestone
• les slices terminees
• les taches en cours
• les couts
• les points de blocage

Ce n’est pas un detail. Sans observabilite, un agent autonome devient vite difficile a faire confiance.

Etape 6 : cloturer un milestone

Une fois un milestone termine, GSD-2 aide a :

• produire des resumes
• structurer les commits
• valider l’etat du travail
• preparer le milestone suivant

Cette transition est importante car elle evite que l’autonomie ne cree une suite de resultats opaques.

Ce qui rend GSD-2 vraiment puissant

1. Isolation de contexte par tache

Le point central. Chaque tache repart avec un contexte propre.

2. Reprise sur incident

Si un processus s’arrete ou se bloque, GSD-2 peut recuperer plus proprement qu’un simple workflow artisanal.

3. Gates de verification

L’outil ne se contente pas d’avancer aveuglement ; il peut integrer des points de verification.

4. Gestion Git automatique

L’historique et la structuration des changements deviennent beaucoup plus propres.

5. Controle du budget

Suivre les couts n’est pas optionnel dans un workflow agentique long.

6. Dispatch reactif parallele

Les versions recentes poussent meme la logique d’orchestration parallele sur certaines branches de travail.

Migration depuis GSD-1

Le changement principal est simple :

• GSD-1 vous aidait a mieux piloter Claude Code
• GSD-2 prend en charge une partie reelle de cette orchestration

La philosophie reste proche, mais l’infrastructure est beaucoup plus solide.

Commandes utiles

Les commandes a retenir sont celles de :

• lancement
• statut
• cloture de milestone
• suivi
• ouverture du report HTML

L’important n’est pas de toutes les memoriser, mais de comprendre le cycle de travail.

Rapport HTML

Le rapport HTML est utile pour revoir :

• ce qui a ete fait
• dans quel ordre
• ce qui a bloque
• quel cout a ete engage

C’est une piece importante pour rendre un systeme autonome presentable a une equipe.

Problemes courants

Sur Ubuntu/Linux, on retrouve souvent :

• erreurs npm globales
• commande gsd introuvable apres install
• version Node trop ancienne
• depot Git non initialise
• processus mort au milieu d’un milestone
• plafond budget atteint

La bonne nouvelle est que ces problemes sont plus des questions d’environnement que de logique interne de l’outil.

GSD-2 vs GSD-1 vs Claude Code seul

Tres simplement :

• Claude Code seul : puissant, mais vous orchestrez tout
• GSD-1 : meilleure discipline de decoupage
• GSD-2 : orchestration autonome reelle

Le gain principal vient du fait qu’on sort d’une logique purement conversationnelle pour entrer dans une logique de systeme.

Exemple de workflow reel

Le cas d’usage le plus parlant est souvent :

• lancer un milestone le soir
• laisser GSD-2 travailler
• verifier les slices terminees le matin
• corriger ou reorienter si besoin
• lancer la suite

On ne supprime pas la supervision humaine. On change simplement son niveau.

Resume

GSD-2 est important parce qu’il transforme une bonne pratique de prompting en vraie couche d’orchestration pour le developpement autonome. Si vous travaillez deja avec Claude Code et que vous sentez les limites des longues sessions manuelles, GSD-2 est probablement l’evolution la plus interessante a tester.