J’ai testé Superpowers pour Claude Code — voici ce qu’il faut vraiment savoir

J’ai failli ignorer Superpowers. Encore un énième framework de compétences, un autre dépôt GitHub promettant de « révolutionner » mon workflow de codage IA. J’en ai vu une douzaine défiler — des README tape-à-l’œil, des démos impressionnantes, puis l’abandon après trois mois. Alors, quand le framework de Jesse Vincent a commencé à engranger des étoiles GitHub plus vite que tout ce que j’avais vu dans l’écosystème Claude Code, ma première réaction a été le scepticisme.

Puis j’ai mené une expérience. Douze sessions Claude Code, six avec Superpowers installé, six sans. Mêmes tâches. Mêmes prompts. Même plafond de dépenses de 2 $ par session. Zéro intervention humaine — entièrement automatisé, pour que mes propres biais ne contaminent pas les résultats.

Les chiffres ont raconté une histoire à laquelle je ne m’attendais pas. Pas celle du « 10x de productivité » que le battage médiatique voudrait vous faire croire. Quelque chose de plus nuancé, de plus utile, et honnêtement de plus intéressant. Superpowers n’a pas rendu Claude plus intelligent. Il a rendu Claude discipliné — et la différence entre intelligence et discipline s’est révélée être le fossé avec lequel je luttais depuis des mois sans m’en rendre compte.

Voici tout ce que j’ai découvert, y compris les aspects que la plupart des critiques omettent soigneusement.

J’ai testé Superpowers pour Claude Code — voici ce qu’il faut vraiment savoir

Si vous avez passé un peu de temps avec Claude Code, vous avez déjà vu ce schéma se répéter. Vous décrivez ce que vous voulez. Claude se met immédiatement à écrire du code. Quinze minutes et 40 000 tokens plus tard, vous réalisez qu’il a mal compris vos besoins dès les trente premières secondes. Tout le résultat est un code techniquement correct qui résout le mauvais problème.

J’ai suivi ce phénomène sur mes propres projets le trimestre dernier. Environ 35 % de mes sessions Claude Code ont nécessité au moins une correction majeure — non pas parce que le modèle était stupide, mais parce qu’il passait directement à l’implémentation sans prendre le temps de réfléchir. Pas de recueil des besoins. Aucune réflexion sur l’architecture. Aucun plan. Juste du code, du code, du code, en espérant que ça passe.

Ça vous rappelle quelque chose ? Vous n’êtes pas seul. C’est le comportement par défaut de tous les agents de codage que j’ai testés. Intelligence brute sans méthodologie. C’est comme embaucher un ingénieur brillant qui refuse de lire le cahier des charges avant d’écrire la première ligne.

Jesse Vincent — le leader du projet Perl et fondateur de Keyboardio, qui a créé Superpowers — a identifié précisément ce mode d’échec. Sa solution n’a pas été de rendre le modèle plus intelligent. Il a imposé la même discipline qu’un lead technique senior exigerait d’un développeur junior : s’arrêter, réfléchir, planifier, puis construire.

Cette distinction compte plus que n’importe quelle fonctionnalité du framework. Et la comprendre est la clé pour savoir si Superpowers va réellement améliorer votre workflow ou simplement ajouter de la lourdeur.

Mais avant d’entrer dans l’architecture, il faut comprendre comment ce framework est passé d’un dépôt GitHub de niche à 121 000 étoiles en quelques mois — car cette trajectoire en dit long sur une douleur ressentie par toute la communauté.

D’un projet annexe à 121 000 étoiles GitHub

Superpowers n’a pas été lancé avec une campagne marketing. Jesse Vincent l’a simplement publié sur GitHub sous le nom obra/superpowers, le décrivant comme « un cadre de compétences agentiques et une méthodologie de développement logiciel qui fonctionne », puis l’a laissé en ligne. Les premiers utilisateurs étaient des développeurs qui suivaient déjà son travail chez Keyboardio et dans la communauté Perl.

Puis, quelque chose s’est produit. Le dépôt a commencé à gagner près de 2 000 étoiles par jour à son apogée. En janvier 2026, Anthropic l’a officiellement accepté dans la place de marché des plugins Claude. En mars, il avait dépassé les 94 000 étoiles. En avril 2026, il en compte plus de 121 000 — ce qui en fait l’un des projets open source à la croissance la plus rapide de l’année, décrochant la 2e place des tendances sur GitHub.

Pourquoi ? Parce que Jesse ne vendait pas un outil. Il formulait une méthodologie qui correspondait à ce que les développeurs expérimentés savaient déjà, mais qu’ils ne pouvaient pas imposer à leurs agents IA : on planifie avant de construire. On teste avant de livrer. On vérifie avant de considérer le travail terminé.

Le framework n’était que le véhicule de cette méthodologie. Et une fois que les développeurs l’ont essayé, le bouche-à-oreille a fait le reste.

J’en ai entendu parler pour la première fois par un collègue qui m’a dit que la qualité de son code dès la première tentative avait augmenté d’environ 40 % après une semaine avec Superpowers. J’étais sceptique face à ce chiffre. Après avoir mené mes propres tests, je pense qu’il est en réalité sous-estimé pour les tâches complexes — et largement surestimé pour les tâches simples. Comme souvent, la réalité est plus nuancée qu’un simple pourcentage.

Laissez-moi vous montrer ce que contient réellement la boîte.

Ce qu’est réellement Superpowers (et ce que ça n’est pas)

Superpowers n’est pas une simple compétence. C’est un système — 14 compétences interconnectées qui s’installent dans Claude Code et orchestrent un flux de travail complet de développement logiciel. Il faut moins le voir comme l’installation d’un plugin que comme l’intégration d’un processus d’ingénierie senior dans votre agent.

Le framework impose cinq phases à chaque interaction :

Clarify — Avant d’écrire la moindre ligne de code, l’agent pose des questions. Pas des questions génériques du type « que voulez-vous ? ». Des clarifications spécifiques et ciblées, conçues pour faire émerger les ambiguïtés de votre demande qui, sinon, deviendraient des bugs plus tard. Lors de mes tests, cette phase a permis de détecter des lacunes dans les exigences environ 60 % du temps, alors que je ne les avais pas remarquées dans mon propre prompt.

Design — C’est ici que Superpowers devient vraiment intéressant. L’agent génère des supports visuels — des tableaux de bord interactifs avec des graphes de force, des grilles de cartes et des mises en page d’options — pour vous aider à visualiser l’architecture avant de vous y engager. Vous choisissez parmi plusieurs approches de conception, et l’agent utilise votre sélection pour guider la construction. Pour être honnête : la première fois que j’ai vu cela en action, j’ai trouvé ça gadget. À la troisième session, j’étais conquis. Visualiser l’architecture avant de commencer à coder élimine toute une catégorie d’incompréhensions.

Plan — L’agent crée des plans de mise en œuvre ultra-détaillés. Pas de simples grandes lignes — de véritables découpages de tâches avec des estimations de temps d’exécution de 2 à 5 minutes, des chemins de fichiers exacts, des signatures de fonctions précises et un ordre de dépendance. Ces plans sont sauvegardés pour référence ultérieure, donc si votre session plante ou si vous souhaitez reprendre plus tard, la feuille de route est déjà prête.

Code — C’est ici que la méthodologie porte ses fruits. Au lieu d’un sprint de codage monolithique, Superpowers segmente l’exécution en tâches distinctes et lance de nouveaux sous-agents pour chacune. Les tâches indépendantes peuvent s’exécuter en parallèle. Chaque tâche comporte des arrêts de sécurité — des points de contrôle où l’agent s’arrête pour vérifier qu’il est toujours sur la bonne voie avant de continuer. Cette architecture à sous-agents signifie qu’un échec sur une tâche n’affecte pas toute la session.

Verify — La phase finale exécute des suites de tests, vérifie que toutes les exigences de la phase de clarification sont respectées, et valide la structure du code avant de déclarer le travail terminé.

La compétence principale — appelée « Utiliser Superpowers » — agit comme un orchestrateur. À chaque fois que vous démarrez une interaction Claude Code, elle lit votre demande et décide laquelle des 14 compétences invoquer. Vous ne déclenchez pas les phases manuellement. Le système gère le routage automatiquement.

Voici ce que Superpowers n’est pas : ce n’est pas un template de prompt. Ce n’est pas un fichier CLAUDE.md rempli d’instructions. Les compétences sont des modules exécutables et composables qui incluent l’application du développement piloté par les tests, des protocoles de débogage systématiques, et — c’est ce qui m’a surpris — une méta-compétence qui permet à Claude d’écrire de nouvelles compétences Superpowers en appliquant les principes du TDD. Le framework peut donc s’étendre lui-même.

Si vous avez suivi ma couverture de l’architecture des compétences d’agent, vous reconnaîtrez ici le schéma de divulgation progressive. Superpowers ne surcharge pas la fenêtre de contexte avec les 14 compétences d’un coup. L’orchestrateur ne charge que la compétence pertinente pour chaque phase, ce qui limite la consommation de tokens. Ce choix de conception explique en grande partie pourquoi le framework permet réellement d’économiser des tokens au lieu de les gaspiller en frais généraux.

Maintenant, à propos de ces économies de tokens — il est temps d’être honnête sur ce que montrent réellement les chiffres.

L’Expérience en 12 Sessions : Ce Que Disent Réellement les Chiffres

Je voulais des données concrètes, pas des impressions. J’ai donc conçu une comparaison contrôlée : 12 sessions Claude Code, 6 avec Superpowers activé, 6 sans. Chaque série comprenait deux tâches simples (utilitaires monofichier), deux tâches moyennes (fonctionnalités multifichiers avec intégration d’API) et deux tâches complexes (fonctionnalités full-stack impliquant des modifications de schéma de base de données, de l’authentification et des composants UI).

Chaque session était plafonnée à 2 $ de dépenses. Zéro intervention humaine. Mêmes prompts, même modèle, mêmes contraintes. La seule variable était l’activation ou non de Superpowers.

Voici les résultats :

Coût et Efficacité des Tokens

Le coût moyen sur les 6 sessions Superpowers était environ 9 % inférieur à celui des 6 sessions de référence. C’est une économie réelle si vous lancez des dizaines de sessions par jour, mais ce n’est pas la réduction spectaculaire que promettent certains avis.

L’histoire des tokens est plus nuancée. Globalement, les sessions Superpowers ont utilisé en moyenne environ 14 % de tokens en moins. Mais cette moyenne masque un schéma critique :

Les tâches simples consommaient en réalité plus de tokens avec Superpowers. Les phases de clarification et de conception ajoutaient une surcharge inutile pour une tâche du type « écris-moi une fonction utilitaire ». Le framework posait des questions de clarification sur un problème qui n’en avait pas, planifiait une architecture pour quelque chose qui tenait dans un seul fichier. La rigueur était réelle — mais pour un script de 50 lignes, c’est excessif.

Les tâches moyennes étaient à peu près à l’équilibre côté tokens mais produisaient un code nettement meilleur. La surcharge de planification était compensée par moins de cycles de correction par la suite.

Les tâches complexes montraient des économies de tokens significatives — et c’est là que Superpowers tient sa réputation. Les phases de planification (clarification, conception, plan) consommaient très peu de tokens — presque uniquement du texte, pas de génération de code. Mais elles évitaient le scénario d’échec coûteux décrit plus haut : écrire des milliers de lignes de code qui résolvent le mauvais problème. Sans Superpowers, les tâches complexes déclenchaient fréquemment plusieurs cycles de redémarrage. Avec, l’agent réussissait bien plus souvent du premier coup.

La Découverte sur la Variance Qui M’a Fait Changer d’Avis

Voici le point de données qui m’a réellement converti du scepticisme à l’utilisation quotidienne.

La variance de consommation de tokens sur les 6 sessions Superpowers était 2 à 3 fois plus faible que sur les sessions de référence. Autrement dit : sans Superpowers, mes tâches complexes étaient totalement imprévisibles. Une session coûtait 0,80 $, la suivante atteignait le plafond de 2 $ pour une tâche similaire. Avec Superpowers, les sessions se regroupaient étroitement autour du même coût.

Pourquoi est-ce important ? Parce que la prévisibilité a de la valeur. Quand je planifie un projet et estime les coûts de développement assisté par IA, j’ai besoin de savoir à peu près combien une fonctionnalité coûtera en tokens. Superpowers rend cette estimation fiable. Les sessions de référence, c’était pile ou face.

Allers-Retours API

Les sessions Superpowers effectuaient en moyenne moins d’allers-retours API. Logique : moins de cycles de correction, donc moins d’échanges aller-retour. Chaque aller-retour ajoute de la latence et consomme des tokens, donc moins de passages se traduit par des économies et des délais d’exécution plus courts.

Scores de Qualité du Code

J’ai évalué la sortie de chaque session selon quatre critères : justesse, structure du code, couverture de tests et gestion des erreurs. Les sessions Superpowers obtenaient des scores nettement supérieurs en justesse, structure et couverture de tests. L’amélioration sur la couverture de tests était particulièrement notable : la compétence TDD intégrée fait que les tests sont écrits en premier, pas ajoutés après coup (ou ignorés, comme c’est souvent le cas dans les sessions de référence).

Découverte inattendue : la robustesse — la capacité du code à gérer les cas limites et entrées inattendues — était légèrement meilleure dans les sessions de référence. Mon hypothèse ? L’approche structurée optimise parfois trop pour le scénario idéal prévu. Sans le framework, l’agent explorait parfois plus librement les cas limites, n’étant pas contraint par un plan prédéfini. C’est un vrai compromis à connaître.

Je veux être transparent sur les limites de cette expérience. Douze sessions, ce n’est pas un échantillon statistiquement significatif. Les tâches ont été conçues par moi, avec mes propres biais. Et surtout, l’expérience était totalement automatisée — alors que Superpowers est conçu pour une itération avec un humain dans la boucle. Les questions de clarification, le choix de la conception, la revue du plan — ce sont des points d’interaction où l’apport du développeur humain rend le framework bien plus efficace. Mon test automatisé a contourné tout cela.

Considérez mes chiffres comme des indicateurs de tendance, pas comme une vérité absolue. Les vrais gains apparaissent quand vous collaborez activement avec le framework, pas quand vous le laissez tourner en pilote automatique.

En parlant de collaboration — laissez-moi vous montrer à quoi ressemblent l’installation et l’utilisation au quotidien.

Installation de Superpowers : Plus rapide que vous ne le pensez

L'installation prend environ 30 secondes. Deux options s'offrent à vous :

Option 1 : Marketplace des plugins Claude

Si vous utilisez Claude Code avec accès à la marketplace, c'est la méthode la plus simple :

/plugin install superpowers@claude-plugins-official

Une seule commande. C'est fait. Superpowers est actif sur toutes vos sessions Claude Code.

Option 2 : Directement depuis GitHub

Si vous préférez installer depuis la source ou souhaitez personnaliser les skills :

# Cloner le dépôt
git clone https://github.com/obra/superpowers.git

# Installer globalement au niveau utilisateur (recommandé)
claude plugins install --global ./superpowers

Jesse recommande d’installer globalement au niveau utilisateur plutôt que par projet. Je suis d’accord : vous voulez que la méthodologie soit disponible partout, pas seulement dans certains dépôts. Les skills sont suffisamment généraux pour améliorer n’importe quel workflow de développement.

Option 3 : Terminal VS Code

Si vous utilisez Claude Code via le terminal de VS Code (ce que je préfère pour la visibilité sur le workflow) :

# Ouvrez le terminal VS Code et exécutez
claude plugin add obra/superpowers

Une fois installé, Superpowers fonctionne automatiquement en arrière-plan. Vous n’avez pas besoin de l’invoquer explicitement. Le skill principal "Using Superpowers" intercepte vos requêtes et les oriente vers les phases appropriées. Si vous souhaitez être rassuré, vous pouvez ajouter "utilise tous les skills superpowers pertinents" à vos prompts — mais d’après mon expérience, la détection automatique est suffisamment fiable pour que cela soit inutile.

Un point que j’ai apprécié : Superpowers ne rentre pas en conflit avec d’autres skills ou plugins déjà installés. Je l’utilise en parallèle de mes skills SEO personnalisés et de plusieurs skills spécifiques à des projets, sans aucun souci. L’orchestrateur est assez intelligent pour savoir quand un autre skill doit prendre le relais.

Si vous préférez que quelqu’un configure l’ensemble de votre environnement de développement Claude Code — Superpowers, skills personnalisés, configurations spécifiques au projet — je propose ce type de prestation. Vous pouvez voir ce que j’ai réalisé sur fiverr.com/s/EgxYmWD.

Passons maintenant à la fonctionnalité qui m’a le plus surpris lors de mes tests.

Le Compagnon Visuel : Pourquoi je suis passé de sceptique à convaincu

J’ai d’abord rejeté le compagnon visuel comme un gadget lors de mes deux premières sessions. Tableaux de bord interactifs ? Graphes de force ? Grilles de cartes ? Cela ressemblait à du sucre UI ajouté à un flux de travail qui, selon moi, devait rester centré sur le terminal.

Puis je me suis retrouvé face à une tâche complexe — une fonctionnalité SaaS multi-locataires avec contrôle d’accès basé sur les rôles, journalisation d’audit et un système de permissions personnalisé. Le genre de fonctionnalité où l’on peut interpréter les exigences de trois façons différentes, chacune menant à une architecture fondamentalement distincte.

Superpowers a généré un compagnon visuel présentant trois approches de conception sous forme de cartes interactives. Chaque carte exposait l’architecture de façon visuelle — modèles de données, points de terminaison API, hiérarchie des composants, flux de permissions. Je pouvais visualiser les compromis en un coup d’œil. L’option A était plus simple mais ne pouvait pas évoluer au-delà de 50 locataires. L’option B gérait la montée en charge mais ajoutait une complexité significative côté base de données. L’option C trouvait un compromis avec une couche de cache.

Sans le compagnon visuel, voici ce qui se serait passé : Claude choisit l’interprétation qu’il juge « la plus probable », code l’ensemble de la fonctionnalité, et je découvre l’inadéquation architecturale après 2 000 lignes de code. Avec le compagnon visuel, j’ai identifié la bonne approche en 45 secondes environ, et l’agent a construit exactement ce dont j’avais besoin du premier coup.

Les questions de clarification fonctionnent de la même manière. Superpowers ne se contente pas de demander « voulez-vous la fonctionnalité X ? » Il fait remonter les ambiguïtés précises de votre demande qu’un développeur senior relèverait lors d’une revue de code. Lors d’une session, il m’a demandé si mon exigence « authentification utilisateur » signifiait une authentification basée sur les sessions, des tokens JWT ou OAuth2 — puis il a expliqué les implications de chaque option pour le reste de l’architecture. Je ne l’avais pas précisé parce que je n’y avais pas encore réfléchi. Cette seule question m’a épargné un cycle d’implémentation complet.

C’est là tout le sens du design « human-in-the-loop » que j’évoquais plus tôt. Le framework est pensé pour ces moments d’interaction. Les ignorer (comme l’a fait mon test automatisé) vous fait perdre une part significative de la valeur.

Les 14 compétences : ce que fait réellement chacune

La plupart des critiques se contentent d’énumérer les compétences sans expliquer quand elles s’activent ni pourquoi elles sont importantes. Voici le détail basé sur mes observations lors de mes tests :

L’Orchestrateur

Utilisation des Superpowers — Le chef d’orchestre. Il lit chaque prompt que vous envoyez et décide quelles compétences activer. Il fonctionne automatiquement à chaque interaction. Vous ne l’appelez jamais directement ; c’est le contrôleur du trafic.

Compétences de la phase de conception

Brainstorming — Génère des options de conception avec des supports visuels. Produit des checklists détaillées qui servent d’input à la phase de planification. Cette compétence s’active avant tout travail d’implémentation et est responsable des grilles de cartes interactives et des graphes de force que j’ai décrits plus haut.

Compétences de la phase de planification

Rédaction de plans — Crée des plans d’implémentation ultra-détaillés. Chaque plan découpe le travail en tâches estimées à 2-5 minutes, inclut les chemins de fichiers exacts et les signatures de fonctions, précise les dépendances entre les tâches, et est sauvegardé comme document de référence. J’ai commencé à utiliser ces plans sauvegardés comme spécifications techniques légères pour mes projets.

Exécution des plans — Prend un plan écrit et coordonne son exécution. C’est là que l’architecture de sous-agents entre en jeu — la compétence lance de nouveaux agents Claude Code pour chaque tâche du plan, gère leurs sorties et s’occupe de l’intégration des tâches terminées.

Compétences de la phase d’exécution

Développement piloté par sous-agents — Déploie des sous-agents indépendants pour exécuter les tâches en parallèle. Si votre plan comporte trois tâches sans dépendances entre elles, cette compétence les exécute toutes les trois simultanément. Le gain de vitesse sur les projets complexes est notable — le temps total chute considérablement lorsque les tâches indépendantes n’ont pas à s’attendre mutuellement.

Dispatch d’agents parallèles — La couche de coordination pour l’exécution parallèle. Gère l’état entre les sous-agents concurrents, garantit que les tâches terminées ne se chevauchent pas, et orchestre la fusion des résultats parallèles.

Compétences de contrôle qualité

Développement piloté par les tests (TDD) — Cette compétence impose la méthodologie TDD : écrire d’abord des tests qui échouent, puis le code minimal pour les faire passer, puis refactoriser. Lors de mes tests, c’est le facteur qui a le plus amélioré la qualité du code. Sans elle, Claude Code écrit d’abord le code d’implémentation et les tests ensuite (voire jamais). Avec elle, chaque fonctionnalité commence par une définition claire du « fini » exprimée sous forme de tests exécutables.

Débogage systématique — Quand quelque chose casse, cette compétence applique un protocole de débogage en quatre phases : identifier la cause racine, analyser les systèmes liés, générer des hypothèses, et tester la correction. Elle évite le « débogage au hasard » où l’agent fait des modifications aléatoires en espérant que l’une d’elles fonctionne. J’ai vu cette compétence sauver des sessions entières qui auraient sinon sombré dans des cycles de corrections inefficaces et coûteux en tokens.

Vérification avant validation — Le dernier contrôle qualité. Avant que Superpowers ne déclare un travail terminé, cette compétence exige l’exécution de la suite de tests, la vérification que toutes les exigences issues de la phase de clarification sont respectées, et la confirmation que le code compile et s’exécute. Fini le « c’est bon » suivi d’échecs immédiats.

Compétences de revue de code

Demande de revue de code — Se déclenche lorsque l’implémentation est terminée. Effectue une revue structurée vérifiant la justesse, le style, la performance et la sécurité avant que le code ne soit validé.

Traitement des retours de revue — Gère les retours de revue de code avec ce que Jesse appelle « rigueur technique, pas simple acquiescement ». La compétence évalue les commentaires de revue de façon critique au lieu d’appliquer aveuglément chaque suggestion. Cela évite que les retours de revue ne dégradent le code parce que l’agent n’ose pas contester les mauvaises propositions.

Compétences du workflow Git

Utilisation des worktrees Git — Crée des worktrees Git isolés pour le développement de fonctionnalités. Garde votre espace de travail principal propre pendant que les expérimentations se déroulent dans des branches séparées. La sélection intelligente des dossiers et la vérification de sécurité évitent la prolifération de worktrees que la gestion manuelle de Git worktree provoque souvent.

Finalisation d’une branche de développement — Guide la clôture du travail de développement en présentant des options structurées : fusionner sur main, créer une PR, ou nettoyer la branche. Cela évite le problème courant des branches inachevées qui encombrent votre dépôt.

La compétence méta

Écriture de compétences — Celle qui enthousiasme les passionnés de frameworks IA. Superpowers peut écrire de nouvelles compétences Superpowers en appliquant les principes TDD. Vous décrivez la capacité souhaitée, et le framework crée une compétence testée et vérifiée qui s’intègre au reste du système. Le framework s’étend lui-même. Je m’en suis servi pour créer des compétences spécifiques à mes projets, respectant les conventions de Superpowers et s’intégrant à sa couche d’orchestration.

L’évaluation honnête : là où Superpowers montre ses limites

Chaque critique que j’ai lue sur Superpowers met l’accent sur les points forts. Voici ce qu’on ne vous dit pas.

Les tâches simples deviennent plus lentes, pas plus rapides. Si vous avez besoin d’une fonction utilitaire rapide, d’un script ponctuel ou d’un refactoring simple, la surcharge clarification-conception-planification ajoute du temps sans réelle valeur ajoutée. J’ai commencé à préfixer mes requêtes simples par « tâche rapide, ignorer la planification : » et l’orchestrateur respecte cela la plupart du temps. Mais par défaut, Superpowers ne fait pas la différence entre une correction de 10 lignes et une fonctionnalité de 10 000 lignes. Il applique la méthodologie complète dans les deux cas.

La connaissance métier ne s’améliore pas. Superpowers rend Claude plus rigoureux, pas plus compétent. Si le modèle ne comprend pas votre framework spécifique, votre domaine métier ou vos API propriétaires, Superpowers n’y changera rien. Il planifiera simplement de façon plus prudente autour des lacunes — ce qui vaut mieux que de coder à l’aveugle, mais les lacunes demeurent. Vous devez toujours fournir du contexte métier dans vos prompts ou dans CLAUDE.md.

Le respect du cahier des charges reste inchangé. Si vos exigences sont erronées ou incomplètes, Superpowers planifiera et exécutera scrupuleusement sur la base de ces exigences erronées ou incomplètes. Les questions de clarification aident — elles comblent certaines lacunes — mais elles ne remplacent pas une spécification bien rédigée. J’ai vu le framework construire une fonctionnalité parfaitement planifiée, parfaitement exécutée, qui correspondait exactement à ce que j’avais demandé, mais pas du tout à ce dont j’avais réellement besoin. La méthodologie n’est aussi bonne que les informations qu’elle reçoit.

Des pics de tokens surviennent. J’ai eu une session où Superpowers a consommé des tokens de façon agressive lors de la phase de brainstorming, générant un compagnon de conception élaboré pour une tâche qui ne le justifiait pas. Les issues GitHub confirment que ce n’est pas un cas isolé — l’issue #953 sur le dépôt décrit un schéma similaire. C’est rare, mais cela arrive, et si vous avez un budget de tokens serré, il faut en être conscient.

La courbe d’apprentissage est réelle pour les équipes. Si vous êtes développeur solo, Superpowers fonctionne immédiatement. Si vous souhaitez le déployer à l’échelle d’une équipe, attendez-vous à des questions. Les compagnons visuels déconcertent les développeurs habitués à un flux de travail purement terminal. Les questions de clarification frustrent ceux qui « veulent juste que ça code ». L’application stricte du TDD agace les développeurs qui n’écrivent pas de tests (et ne sont pas prêts à s’y mettre). L’adoption nécessite de l’adhésion, pas seulement une installation.

Ce ne sont pas des obstacles rédhibitoires. Ce sont des compromis. Et les connaître à l’avance vous permet de décider si le compromis est pertinent pour votre situation.

Quand utiliser Superpowers (et quand s’en passer)

Après un mois d’utilisation quotidienne, voici mon cadre de décision :

Utilisez Superpowers lorsque :

• La tâche implique plusieurs fichiers, services ou décisions architecturales
• Vous développez une fonctionnalité qui doit s’intégrer à du code existant
• Les exigences sont ambiguës ou suffisamment complexes pour être mal interprétées
• Vous accordez de l’importance à la couverture de tests et à la structure du code, pas seulement à « est-ce que ça fonctionne »
• Vous estimez les coûts d’un projet et avez besoin d’une consommation de jetons prévisible
• Vous travaillez sur une base de code que vous allez maintenir sur le long terme

Évitez Superpowers lorsque :

• Vous avez besoin d’un script ou utilitaire ponctuel et rapide
• La tâche consiste en une simple correction de bug avec une solution évidente
• Vous explorez ou prototypez et ne voulez pas la lourdeur de la planification
• Le budget de jetons est extrêmement serré et la tâche est simple

Le point idéal — là où Superpowers offre le meilleur rapport valeur/jeton dépensé — ce sont les tâches de complexité moyenne à élevée dans des bases de code actives et maintenues. C’est là que la planification évite des reprises coûteuses, que le TDD détecte les régressions, et que l’architecture en sous-agents accélère la mise en œuvre en parallèle.

Superpowers vs. Les Alternatives : Comparaison Rapide

Superpowers n'est pas le seul cadre structuré pour Claude Code. Deux alternatives notables sont GSD (Get Stuff Done) et gstack. Voici comment elles se distinguent à un niveau global :

La question n'est pas « lequel est le meilleur », mais « lequel correspond à votre tâche ». J'utilise Superpowers par défaut et je le désactive parfois pour des tâches rapides où l'approche légère de GSD est plus adaptée. Ce sont des outils complémentaires, pas des concurrents.

Ce que cela change dans ma façon de travailler aujourd’hui

Après un mois d’utilisation, Superpowers a transformé mon workflow Claude Code de trois façons précises.

Premièrement, j’ai cessé de considérer Claude Code comme un simple générateur de code pour le voir comme un véritable partenaire de développement. Les phases de clarification et de conception imposent une discussion qui n’existait pas auparavant. Mes prompts sont devenus plus courts et plus ciblés, car je sais que le framework posera les bonnes questions de suivi. Je n’essaie plus de tout condenser dans un seul prompt.

Deuxièmement, la précision de mes estimations de projet s’est nettement améliorée. L’utilisation prévisible des tokens me permet de dimensionner les fonctionnalités assistées par l’IA avec confiance. « Cette fonctionnalité nécessitera environ X tokens à implémenter » est désormais une affirmation que je peux faire et qui s’avère correcte dans une marge raisonnable. Avant Superpowers, cette estimation était si imprécise qu’on aurait pu y faire passer un camion.

Troisièmement — et cela m’a surpris — je rédige de meilleures spécifications. Les questions de clarification m’ont appris quelles informations l’agent a réellement besoin, par opposition à ce que j’incluais par habitude. Mes specs sont plus courtes, plus précises et nécessitent moins d’itérations. Le framework m’a autant formé que l’agent.

Superpowers est-il l’outil idéal pour tout le monde ? Non. Si vous effectuez des tâches simples, du prototypage ou travaillez dans un domaine où la planification n’apporte rien, il vous ralentira. Mais si vous développez de vrais logiciels — des fonctionnalités qui doivent fonctionner, s’intégrer et être maintenues — la discipline en cinq phases n’est pas une surcharge. C’est ainsi que les professionnels construisent du logiciel. Le framework ne fait qu’imposer ce que les bons ingénieurs font déjà, et l’apporte à une IA qui avait désespérément besoin de structure.

Les 121 000 étoiles GitHub ne sont pas du battage. Ce sont 121 000 développeurs qui ont buté sur le même mur que moi — une IA brillante, zéro discipline — et ont trouvé la même réponse.

Installez-le. Utilisez-le sur votre prochaine tâche complexe. Puis décidez par vous-même. C’est ce que j’ai fait, et l’expérience a parlé plus fort que n’importe quel avis.

Foire aux questions

Superpowers fonctionne-t-il avec tous les modèles Claude Code ?

Superpowers fonctionne avec n'importe quel modèle disponible via Claude Code, y compris Opus 4.6 et Sonnet 4.6. Les compétences sont indépendantes du modèle — elles modifient le flux de travail, pas les capacités fondamentales du modèle. Les améliorations de performance évoluent avec la puissance du modèle, donc les sessions Opus affichent généralement des gains de qualité plus importants que les sessions Sonnet.

Comment désactiver Superpowers pour des tâches simples ?

Préfixez votre prompt avec « tâche rapide » ou « ignorer la planification » et l'orchestrateur contournera généralement le cycle complet clarification-conception-planification. Vous pouvez aussi désactiver temporairement le plugin avec /plugin disable superpowers et le réactiver avec /plugin enable superpowers. Pour un contrôle plus fin, chaque compétence peut être activée ou désactivée individuellement dans les paramètres du plugin.

Superpowers entre-t-il en conflit avec d'autres plugins ou compétences Claude Code ?

Après quatre mois d'utilisation quotidienne, Superpowers cohabite parfaitement avec les autres plugins et compétences personnalisées. L'orchestrateur est conçu pour reconnaître lorsqu'une autre compétence doit traiter une requête et s'efface alors automatiquement. En cas de conflit, vérifiez que vos autres compétences ne définissent pas de conditions de déclenchement qui se chevauchent avec les phases principales de Superpowers.

Superpowers est-il gratuit ?

Oui. Superpowers est entièrement open source sous licence MIT, hébergé sur github.com/obra/superpowers. Il n'y a ni niveaux payants, ni fonctionnalités premium, ni limites d'utilisation. L'ensemble du framework — les 14 compétences — est gratuit à installer, utiliser et modifier.

Dans quelle mesure Superpowers réduit-il les coûts en tokens ?

D'après mon expérience sur 12 sessions : environ 9 % de réduction des coûts et 14 % de réduction des tokens en moyenne, avec des économies concentrées sur les tâches de complexité moyenne à élevée. Les tâches simples peuvent en fait consommer plus de tokens à cause de la surcharge de planification. Le critère le plus intéressant reste la régularité : la variance d'utilisation des tokens a chuté de 2 à 3 fois, rendant l'estimation des coûts de projet bien plus fiable.

Travaillons ensemble

Vous souhaitez développer des systèmes d’IA, automatiser vos workflows ou faire évoluer votre infrastructure technologique ? Je serais ravi de vous accompagner.

• Fiverr (développements sur mesure & intégrations) : fiverr.com/s/EgxYmWD
• Portfolio : mejba.me
• Ramlit Limited (solutions d’entreprise) : ramlit.com
• ColorPark (design & branding) : colorpark.io
• xCyberSecurity (services de sécurité) : xcybersecurity.io