Utilisateur de Get Shit Done ? Migrez immédiatement vers la version community

Que s’est-il passé avec l’auteur original de Get Shit Done ?

Si vous utilisez régulièrement des agents IA pour développer vos projets, vous connaissez peut-être déjà Get Shit Done (GSD). Cet outil s’était rapidement imposé dans l’écosystème Claude Code grâce à une approche assez intelligente du développement assisté par IA.

Le principe était simple : aider l’agent à structurer correctement une implémentation complexe en plusieurs étapes cohérentes et non bloquantes. Analyse du besoin, découpage des tâches, génération de code, rédaction des tests, validation progressive… le workflow proposé était réellement efficace. Personnellement, je l’ai beaucoup utilisé sur plusieurs projets.

Cependant, la situation a récemment pris une tournure beaucoup plus problématique.

L’auteur principal du projet, connu sous le pseudonyme glittercowboy sur GitHub et officialtaches sur Reddit, a lancé un token crypto nommé $GSD autour du projet. Après une montée rapide de la valeur du token, celui-ci aurait effectué ce qu’on appelle communément un rug pull : disparition soudaine, token abandonné, réseaux sociaux supprimés, plus aucune communication publique.

À partir du moment où un mainteneur agit de manière aussi douteuse financièrement, il devient difficile de continuer à faire confiance à un outil disposant potentiellement d’un accès très profond à votre environnement de développement.

Et c’est précisément là que le vrai problème commence.

Pourquoi conserver l’ancienne version peut devenir dangereux

Les outils comme Get Shit Done ne sont pas de simples extensions visuelles ou plugins anodins.

Ils interagissent directement avec :

votre filesystem local ;
les hooks de Claude Code ;
des commandes shell ;
des serveurs MCP ;
parfois même des scripts exécutés automatiquement pendant certaines phases de développement.

Autrement dit : vous accordez énormément de privilèges à ce type d’outil.

Dans ce contexte, continuer à utiliser une version maintenue par une personne ayant déjà rompu la confiance de sa communauté représente un risque difficilement justifiable. Même sans comportement malicieux immédiat, rien ne garantit qu’une future mise à jour ne puisse pas introduire du code problématique ou une forme de supply-chain attack.

C’est d’ailleurs pour cette raison qu’une partie de la communauté a rapidement forké le projet afin de créer une version communautaire indépendante.

L’auteur original n’est plus impliqué dans ce nouveau repository, et le projet est désormais maintenu collectivement par plusieurs développeurs. Cette approche réduit fortement le risque de dépendre d’un unique mainteneur opaque.

Comment supprimer l’ancienne version de Get Shit Done

L’utilisateur Linuxzhino, qui a notamment soulevé plusieurs points importants sur Reddit, propose les commandes suivantes pour supprimer l’installation NPM classique de GSD.

⚠️ Si vous utilisez plusieurs machines, pensez à effectuer cette opération sur chacun de vos appareils.

# Installation globale via npm
npm uninstall -g get-shit-done-cc
npm uninstall -g @/gsd-build/sdk

# Installation via npx
npx get-shit-done-cc --uninstall --global

# Ou installation locale
npx get-shit-done-cc --uninstall --local

Il recommande également de vérifier et nettoyer les dossiers suivants :

~/.npm/_npx/

Ainsi que les éventuels dossiers liés à GSD dans :

~/.claude/

Installer la version communautaire

Une fois l’ancienne version supprimée, vous pouvez installer le fork communautaire avec :

npx @opengsd/get-shit-done-redux@latest

Dans mon cas, la désinstallation classique ne fonctionnait pas

De mon côté, j’utilisais Get Shit Done depuis les toutes premières versions, avant même l’arrivée du package NPM officiel.

Résultat : les commandes de désinstallation classiques ne supprimaient pas correctement toutes les traces du projet dans Claude Code.

J’ai donc écrit un script Shell permettant de :

analyser automatiquement la configuration actuelle ;
sauvegarder l’environnement avant toute modification ;
supprimer les hooks et références GSD ;
nettoyer les fichiers JSON proprement ;
vérifier que les configurations restent valides après modification.

L’objectif était surtout d’éviter les suppressions “brutales” au rm -rf un peu dangereuses sur des configurations sensibles.

Script complet de désinstallation « propre » de GSD

#!/usr/bin/env bash
#
# uninstall-gsd.sh — Désinstalle proprement "Get Shit Done" (GSD) de Claude Code.
#
# Ce que fait le script :
#   1. Sauvegarde ~/.claude (fichiers de config) avant toute modification.
#   2. Supprime les fichiers GSD : dossier get-shit-done, commands/gsd,
#      agents/gsd-*.md, hooks/gsd-*.js, cache/gsd-*.json.
#   3. Retire les hooks GSD référencés dans settings.json (parsing JSON via Python).
#   4. Retire les entrées "gsd:*" dans ~/.claude.json (parsing JSON via Python).
#   5. Valide que les deux fichiers JSON restent syntaxiquement corrects.
#
# Sûr et rejouable (idempotent) : relancer le script ne casse rien.
#
# USAGE :
#   ./uninstall-gsd.sh            # DRY-RUN : montre ce qui serait fait, ne modifie RIEN
#   ./uninstall-gsd.sh --apply    # Exécute réellement la suppression
#
set -euo pipefail

# ----------------------------------------------------------------------------
# Réglages
# ----------------------------------------------------------------------------
CLAUDE_DIR="${HOME}/.claude"
SETTINGS_JSON="${CLAUDE_DIR}/settings.json"
CLAUDE_JSON="${HOME}/.claude.json"
STAMP="$(date +%Y%m%d-%H%M%S)"
BACKUP_DIR="${HOME}/.claude.gsd-backup-${STAMP}"

APPLY=0
[[ "${1:-}" == "--apply" ]] && APPLY=1

# Couleurs (désactivées si pas un terminal)
if [[ -t 1 ]]; then
  B="\033[1m"; G="\033[32m"; Y="\033[33m"; R="\033[31m"; C="\033[36m"; N="\033[0m"
else
  B=""; G=""; Y=""; R=""; C=""; N=""
fi

log()  { echo -e "${C}•${N} $*"; }
ok()   { echo -e "${G}✓${N} $*"; }
warn() { echo -e "${Y}!${N} $*"; }
err()  { echo -e "${R}✗${N} $*" >&2; }

run() {
  # Exécute une commande, ou l'affiche seulement en dry-run.
  if [[ "$APPLY" -eq 1 ]]; then
    eval "$@"
  else
    echo -e "   ${Y}[dry-run]${N} $*"
  fi
}

# ----------------------------------------------------------------------------
# 0. Pré-vérifications
# ----------------------------------------------------------------------------
echo -e "${B}=== Désinstallation de Get Shit Done (GSD) ===${N}"
if [[ "$APPLY" -eq 1 ]]; then
  warn "Mode RÉEL : les modifications seront appliquées."
else
  log "Mode DRY-RUN : rien ne sera modifié. Ajoute ${B}--apply${N} pour exécuter."
fi
echo

if ! command -v python3 >/dev/null 2>&1; then
  err "python3 introuvable. Il est requis pour éditer le JSON en sécurité."
  exit 1
fi

if [[ ! -d "$CLAUDE_DIR" ]]; then
  err "Répertoire ${CLAUDE_DIR} introuvable. Rien à faire."
  exit 1
fi

# ----------------------------------------------------------------------------
# 1. Sauvegarde
# ----------------------------------------------------------------------------
log "Sauvegarde de la configuration…"
if [[ "$APPLY" -eq 1 ]]; then
  # rsync ignore les liens cassés (ex. debug/latest) qui font échouer cp -r.
  if command -v rsync >/dev/null 2>&1; then
    rsync -a --quiet "${CLAUDE_DIR}/" "${BACKUP_DIR}/" 2>/dev/null || true
  else
    cp -R "${CLAUDE_DIR}" "${BACKUP_DIR}" 2>/dev/null || true
  fi
  [[ -f "$CLAUDE_JSON" ]] && cp "$CLAUDE_JSON" "${BACKUP_DIR}.claude.json"
  ok "Sauvegarde : ${BACKUP_DIR}"
else
  echo -e "   ${Y}[dry-run]${N} sauvegarderait ${CLAUDE_DIR} -> ${BACKUP_DIR}"
fi
echo

# ----------------------------------------------------------------------------
# 2. Suppression des fichiers GSD
# ----------------------------------------------------------------------------
log "Suppression des fichiers GSD…"
TARGETS=(
  "${CLAUDE_DIR}/get-shit-done"
  "${CLAUDE_DIR}/commands/gsd"
  "${CLAUDE_DIR}/cache/gsd-update-check.json"
)
for t in "${TARGETS[@]}"; do
  if [[ -e "$t" ]]; then
    run "rm -rf \"$t\""
    ok "supprimé : $t"
  fi
done

# agents/gsd-*.md et hooks/gsd-*.js (globs, gérés un par un pour le dry-run)
shopt -s nullglob
for f in "${CLAUDE_DIR}"/agents/gsd-*.md "${CLAUDE_DIR}"/hooks/gsd-*.js "${CLAUDE_DIR}"/cache/gsd-*.json; do
  run "rm -f \"$f\""
  ok "supprimé : $f"
done
shopt -u nullglob
echo

# ----------------------------------------------------------------------------
# 3. Nettoyage JSON via Python (settings.json + .claude.json)
# ----------------------------------------------------------------------------
# Le cœur fiable : on parse, on filtre, on réécrit. Pas de sed sur du JSON.
clean_json() {
  local file="$1"
  [[ -f "$file" ]] || { warn "absent, ignoré : $file"; return 0; }

  APPLY="$APPLY" python3 - "$file" <<'PY'
import json, sys, os

path = sys.argv[1]
apply = os.environ.get("APPLY") == "1"

with open(path, "r", encoding="utf-8") as fh:
    data = json.load(fh)

changes = []

def mentions_gsd(value):
    """True si une valeur (str/dict/list) référence gsd ou get-shit-done."""
    s = json.dumps(value).lower()
    return "gsd" in s or "get-shit-done" in s

# --- a) Clés de premier niveau "gsd:*" (commandes dans .claude.json) ---------
if isinstance(data, dict):
    for key in [k for k in data if isinstance(k, str) and k.lower().startswith("gsd:")]:
        changes.append(f'clé supprimée : "{key}"')
        del data[key]

# --- b) Hooks GSD (dans settings.json sous "hooks") --------------------------
hooks = data.get("hooks") if isinstance(data, dict) else None
if isinstance(hooks, dict):
    for event in list(hooks.keys()):
        entries = hooks[event]
        if not isinstance(entries, list):
            continue
        new_entries = []
        for entry in entries:
            # Chaque "entry" contient souvent une sous-liste "hooks".
            if isinstance(entry, dict) and isinstance(entry.get("hooks"), list):
                kept = [h for h in entry["hooks"] if not mentions_gsd(h)]
                if len(kept) != len(entry["hooks"]):
                    changes.append(f'hook GSD retiré dans "{event}"')
                if kept:
                    entry["hooks"] = kept
                    new_entries.append(entry)
                # si kept est vide, on jette l'entry entière
            elif mentions_gsd(entry):
                changes.append(f'entrée GSD retirée dans "{event}"')
                # jetée
            else:
                new_entries.append(entry)
        if new_entries:
            hooks[event] = new_entries
        else:
            del hooks[event]
            changes.append(f'événement de hook vidé puis supprimé : "{event}"')
    if not hooks:
        del data["hooks"]

# --- Rapport + écriture ------------------------------------------------------
if not changes:
    print(f"   (rien à nettoyer dans {os.path.basename(path)})")
    sys.exit(0)

for c in changes:
    print(f"   - {c}")

if apply:
    # Écriture atomique : fichier temporaire puis remplacement.
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8") as fh:
        json.dump(data, fh, indent=2, ensure_ascii=False)
        fh.write("\n")
    os.replace(tmp, path)
    print(f"   => {os.path.basename(path)} mis à jour.")
else:
    print(f"   [dry-run] {os.path.basename(path)} ne sera pas modifié.")
PY
}

log "Nettoyage de settings.json…"
clean_json "$SETTINGS_JSON"
echo

log "Nettoyage de .claude.json…"
clean_json "$CLAUDE_JSON"
echo

# ----------------------------------------------------------------------------
# 4. Validation finale des JSON
# ----------------------------------------------------------------------------
log "Validation de la syntaxe JSON…"
valid_all=1
for f in "$SETTINGS_JSON" "$CLAUDE_JSON"; do
  [[ -f "$f" ]] || continue
  if python3 -m json.tool "$f" >/dev/null 2>&1; then
    ok "JSON valide : $f"
  else
    err "JSON INVALIDE : $f"
    valid_all=0
  fi
done
echo

# ----------------------------------------------------------------------------
# 5. Contrôle : reste-t-il des traces ?
# ----------------------------------------------------------------------------
log "Recherche de traces résiduelles…"
leftovers="$(find "$CLAUDE_DIR" -maxdepth 3 \( -iname '*gsd*' -o -iname 'get-shit-done' \) -print 2>/dev/null || true)"
if [[ -n "$leftovers" ]]; then
  warn "Fichiers restants :"
  echo "$leftovers" | sed 's/^/     /'
else
  ok "Aucun fichier GSD restant."
fi
echo

# ----------------------------------------------------------------------------
# Bilan
# ----------------------------------------------------------------------------
if [[ "$APPLY" -eq 0 ]]; then
  echo -e "${B}Dry-run terminé.${N} Relance avec ${B}--apply${N} pour exécuter :"
  echo -e "   ${C}bash $(basename "$0") --apply${N}"
elif [[ "$valid_all" -eq 1 ]]; then
  echo -e "${G}${B}Désinstallation terminée avec succès.${N}"
  echo -e "Sauvegarde conservée dans : ${BACKUP_DIR}"
  echo -e "Redémarre Claude Code pour appliquer."
else
  err "Des fichiers JSON sont invalides. Restaure depuis la sauvegarde :"
  echo -e "   cp -R \"${BACKUP_DIR}/.\" \"${CLAUDE_DIR}/\""
  echo -e "   cp \"${BACKUP_DIR}.claude.json\" \"${CLAUDE_JSON}\""
  exit 1
fi

Comment utiliser le script

Copiez le script dans un fichier nommé :

uninstall-gsd.sh

Puis exécutez les commandes suivantes :

# Rendre le script exécutable
chmod +x uninstall-gsd.sh

# Tester sans modifier quoi que ce soit
./uninstall-gsd.sh

# Appliquer réellement les modifications
./uninstall-gsd.sh --apply

Je recommande fortement d’effectuer d’abord un dry-run afin de vérifier exactement ce qui sera modifié sur votre machine.

Get Shit Done est-il encore réellement utile aujourd’hui ?

Honnêtement : plus autant qu’avant.

Non pas parce que l’idée derrière GSD était mauvaise. Au contraire, le projet a probablement participé à populariser certaines bonnes pratiques autour des workflows agents.

Mais l’écosystème IA dev a énormément évolué ces derniers mois.

Claude Code, Codex et les agents modernes sont devenus beaucoup plus fiables pour :

gérer de gros refactors ;
implémenter des fonctionnalités complexes ;
maintenir un contexte cohérent ;
exécuter des workflows de développement relativement avancés.

La qualité finale dépend évidemment toujours :

de vos prompts ;
de votre architecture ;
de vos serveurs MCP ;
de votre capacité à bien guider l’agent.

Mais beaucoup moins qu’il y a encore quelques mois.

Aujourd’hui, je considère surtout Get Shit Done comme un outil ayant eu une vraie utilité à un moment précis de l’évolution des agents IA… mais dont la pertinence est devenue beaucoup moins évidente avec les progrès récents de Claude Code et Codex.

CQFD

Le vrai problème derrière l’affaire Get Shit Done n’est probablement pas uniquement la disparition de son créateur.

C’est surtout le rappel d’un point devenu essentiel en 2026 : les outils IA de développement disposent désormais d’un accès extrêmement profond à nos environnements locaux.

Lorsqu’un projet est maintenu par une seule personne, sans réelle transparence ni gouvernance communautaire, le risque devient rapidement important. D’autant plus lorsque des enjeux financiers ou spéculatifs viennent s’y mêler.

Heureusement, l’écosystème open source réagit généralement vite.

Le fork communautaire permet aujourd’hui de continuer à utiliser l’idée derrière GSD dans un cadre beaucoup plus sain, transparent et crédible.

Utilisateur de Get Shit Done ? Migrez immédiatement vers la version community

Que s’est-il passé avec l’auteur original de Get Shit Done ?

Pourquoi conserver l’ancienne version peut devenir dangereux

Comment supprimer l’ancienne version de Get Shit Done

Installer la version communautaire

Dans mon cas, la désinstallation classique ne fonctionnait pas

Script complet de désinstallation « propre » de GSD

Comment utiliser le script

Get Shit Done est-il encore réellement utile aujourd’hui ?

CQFD

Plus de publications

Utilisateur de Get Shit Done ? Migrez immédiatement vers la version community

UGREEN DXP2800 : simple et efficace!