Superpowers für Claude Code im Praxistest – Das ist mein Fazit

Ich hätte Superpowers fast ignoriert. Noch ein weiteres Skills-Framework, noch ein weiteres GitHub-Repo, das verspricht, meinen AI-Coding-Workflow zu „revolutionieren“. Ich habe ein Dutzend solcher Projekte kommen und gehen sehen – auffällige READMEs, beeindruckende Demos, nach drei Monaten aufgegeben. Als das Framework von Jesse Vincent dann jedoch schneller GitHub-Stars sammelte als alles, was ich bisher im Claude-Code-Ökosystem gesehen hatte, war meine erste Reaktion Skepsis.

Dann habe ich ein Experiment gemacht. Zwölf Claude-Code-Sessions, sechs mit installiertem Superpowers, sechs ohne. Gleiche Aufgaben. Gleiche Prompts. Gleiches $2-Ausgabenlimit pro Durchlauf. Null menschliche Eingriffe – komplett automatisiert, damit meine eigenen Vorurteile die Ergebnisse nicht verfälschen konnten.

Die Zahlen erzählten eine Geschichte, mit der ich nicht gerechnet hatte. Nicht die „10x Produktivität“-Story, die der Hype einem weismachen will. Etwas Nuancierteres, Nützlicheres und ehrlich gesagt Interessanteres. Superpowers machte Claude nicht schlauer. Es machte Claude disziplinierter – und der Unterschied zwischen Intelligenz und Disziplin war genau die Lücke, mit der ich monatelang gekämpft hatte, ohne es zu merken.

Hier ist alles, was ich herausgefunden habe – inklusive der Teile, die die meisten Reviews gerne auslassen.

Superpowers für Claude Code im Praxistest – Das ist mein Fazit

Wer ernsthaft mit Claude Code gearbeitet hat, kennt dieses Muster. Man beschreibt, was man will. Claude beginnt sofort, Code zu schreiben. Fünfzehn Minuten und 40.000 Tokens später merkt man, dass das Modell die Anforderungen schon in den ersten dreißig Sekunden missverstanden hat. Das gesamte Ergebnis ist technisch korrekter Code, der aber das falsche Problem löst.

Ich habe das im letzten Quartal in meinen eigenen Projekten verfolgt. Rund 35 % meiner Claude-Code-Sessions erforderten mindestens eine größere Kurskorrektur – nicht, weil das Modell dumm war, sondern weil es direkt mit der Implementierung loslegte, ohne innezuhalten und nachzudenken. Keine Anforderungsanalyse. Keine Architekturüberlegungen. Kein Plan. Einfach nur Code, Code, Code – und hoffen, dass es passt.

Kommt dir das bekannt vor? Du bist nicht allein. Das ist das Standardverhalten jedes Coding-Agents, den ich getestet habe. Reine Intelligenz ohne Methodik. Es ist, als würde man einen brillanten Ingenieur einstellen, der sich weigert, das Lastenheft zu lesen, bevor er die erste Zeile schreibt.

Jesse Vincent – der Perl-Projektleiter und Keyboardio-Gründer, der Superpowers entwickelt hat – hat genau dieses Fehlverhalten erkannt. Seine Lösung war nicht, das Modell schlauer zu machen. Sondern die gleiche Disziplin zu erzwingen, die ein Senior Engineering Lead von einem Junior-Entwickler verlangen würde: Anhalten, nachdenken, planen, dann bauen.

Diese Unterscheidung ist wichtiger als jedes einzelne Feature des Frameworks. Und sie zu verstehen, ist der Schlüssel, um zu wissen, ob Superpowers deinem Workflow wirklich hilft – oder nur zusätzlichen Overhead erzeugt.

Doch bevor ich auf die Architektur eingehe, musst du verstehen, wie dieses Framework vom Nischen-GitHub-Repo zu 121.000 Stars in wenigen Monaten wurde – denn dieser Aufstieg sagt viel über einen Schmerzpunkt aus, den die gesamte Community gespürt hat.

Vom Nebenprojekt zu 121.000 GitHub-Sternen

Superpowers startete ohne Marketingkampagne. Jesse Vincent veröffentlichte es auf GitHub unter obra/superpowers, beschrieb es als „ein agentisches Skills-Framework & eine Software-Entwicklungsmethodik, die funktioniert“, und ließ es einfach stehen. Die ersten Nutzer waren Entwickler, die seine Arbeit bereits von Keyboardio und aus der Perl-Community kannten.

Dann passierte etwas. Das Repository gewann auf seinem Höhepunkt fast 2.000 Sterne pro Tag dazu. Im Januar 2026 wurde es offiziell von Anthropic in den Claude-Plugins-Marktplatz aufgenommen. Im März hatte es die Marke von 94.000 Sternen überschritten. Im April 2026 steht es bei über 121.000 – damit ist es eines der am schnellsten wachsenden Open-Source-Projekte des Jahres und belegt Platz 2 der Trending-Repos auf GitHub.

Warum? Weil Jesse kein Tool verkauft hat. Er hat eine Methodik formuliert, die dem entsprach, was erfahrene Entwickler längst wussten, aber ihren KI-Agenten bisher nicht beibringen konnten: Du planst, bevor du baust. Du testest, bevor du auslieferst. Du überprüfst, bevor du etwas als fertig erklärst.

Das Framework war lediglich das Vehikel für diese Methodik. Und sobald Entwickler es ausprobierten, verbreitete sich die Nachricht ganz organisch.

Ich habe zum ersten Mal davon von einem Kollegen gehört, der mir erzählte, dass die Codequalität bei seinen Erstversuchen nach einer Woche mit Superpowers um etwa 40 % gestiegen sei. Ich war skeptisch gegenüber dieser Zahl. Nach meinen eigenen Tests halte ich sie bei komplexen Aufgaben tatsächlich für konservativ – und bei einfachen Aufgaben für deutlich übertrieben. Die Realität ist, wie so oft, komplizierter als eine einzelne Prozentangabe.

Lassen Sie mich zeigen, was wirklich in der Box steckt.

Was Superpowers eigentlich ist (und was nicht)

Superpowers ist keine einzelne Fähigkeit. Es ist ein System — 14 miteinander verbundene Skills, die in Claude Code installiert werden und einen vollständigen Softwareentwicklungs-Workflow orchestrieren. Man sollte es weniger als das Installieren eines Plugins und mehr als das Onboarding eines Senior-Engineering-Prozesses für deinen Agenten betrachten.

Das Framework erzwingt bei jeder Interaktion fünf Phasen:

Clarify — Bevor auch nur eine einzige Codezeile geschrieben wird, stellt der Agent Fragen. Keine generischen „Was möchtest du?“-Fragen. Sondern spezifische, gezielte Nachfragen, die darauf ausgelegt sind, Unklarheiten in deiner Anfrage aufzudecken, die sonst später zu Bugs werden würden. In meinen Tests hat diese Phase etwa 60 % der Anforderungslücken aufgedeckt, die mir in meinem eigenen Prompt nicht aufgefallen waren.

Design — Hier wird Superpowers wirklich interessant. Der Agent generiert visuelle Begleiter — interaktive Dashboards mit Kraftdiagrammen, Kartenrastern und Optionslayouts —, damit du die Architektur sehen kannst, bevor du dich darauf festlegst. Du wählst aus mehreren Designansätzen, und der Agent nutzt deine Auswahl, um den Build zu steuern. Ehrlich gesagt: Beim ersten Mal hielt ich das für Spielerei. Nach der dritten Session war ich süchtig. Die Architektur visuell zu sehen, bevor das Coding beginnt, eliminiert eine ganze Kategorie von Missverständnissen.

Plan — Der Agent erstellt hyperdetaillierte Implementierungspläne. Keine vagen Skizzen — sondern echte Aufgabenaufschlüsselungen mit geschätzten Bearbeitungszeiten von 2–5 Minuten, exakten Dateipfaden, spezifischen Funktionssignaturen und Abhängigkeitsreihenfolgen. Diese Pläne werden für die spätere Referenz gespeichert, sodass du, falls deine Session abstürzt oder du später fortsetzen möchtest, bereits eine Roadmap hast.

Code — Hier zahlt sich die Methodik aus. Anstatt eines monolithischen Coding-Sprints zerlegt Superpowers die Ausführung in einzelne Aufgaben und startet für jede einen eigenen Sub-Agenten. Unabhängige Aufgaben können parallel laufen. Jede Aufgabe hat Sicherheitsstopps — Checkpoints, an denen der Agent pausiert, um zu überprüfen, ob er noch auf Kurs ist, bevor es weitergeht. Diese Sub-Agenten-Architektur bedeutet, dass ein Fehler in einer Aufgabe nicht die gesamte Session beeinträchtigt.

Verify — In der letzten Phase werden Test-Suites ausgeführt, überprüft, ob alle Anforderungen aus der Clarify-Phase erfüllt sind, und die Code-Struktur validiert, bevor die Arbeit als abgeschlossen gilt.

Die Master-Skill — genannt „Using Superpowers“ — fungiert als Orchestrator. Jedes Mal, wenn du eine Claude-Code-Interaktion startest, liest sie deine Anfrage und entscheidet, welche der 14 Skills aufgerufen werden. Du musst keine Phasen manuell auslösen. Das System übernimmt das Routing automatisch.

Was Superpowers nicht ist: Es ist kein Prompt-Template. Es ist keine CLAUDE.md-Datei voller Anweisungen. Die Skills sind ausführbare, kombinierbare Module, die Test-Driven-Development-Erzwingung, systematische Debugging-Protokolle und — das hat mich überrascht — eine Meta-Skill enthalten, mit der Claude neue Superpowers-Skills nach TDD-Prinzipien schreiben kann. Das Framework kann sich selbst erweitern.

Wenn du meine Berichterstattung zur Agenten-Skills-Architektur verfolgt hast, wirst du das Muster der progressiven Offenlegung hier wiedererkennen. Superpowers lädt nicht alle 14 Skills gleichzeitig ins Kontextfenster. Der Orchestrator lädt nur den relevanten Skill für jede Phase und hält so den Tokenverbrauch gering. Diese Designentscheidung ist ein wesentlicher Grund, warum das Framework tatsächlich Tokens spart, anstatt sie für Overhead zu verbrennen.

Nun zu den Token-Einsparungen — hier muss ich ehrlich werden, was die Zahlen tatsächlich zeigen.

Das 12-Sitzungen-Experiment: Was die Zahlen wirklich sagen

Ich wollte echte Daten, keine Bauchgefühle. Also habe ich einen kontrollierten Vergleich entworfen: 12 Claude-Code-Sitzungen, 6 mit aktivierten Superpowers, 6 ohne. Jede Gruppe umfasste zwei einfache Aufgaben (Einzeldatei-Utilities), zwei mittlere Aufgaben (mehrteilige Features mit API-Integration) und zwei komplexe Aufgaben (Full-Stack-Features mit Datenbankschema-Änderungen, Authentifizierung und UI-Komponenten).

Jede Sitzung lief mit einem Ausgabenlimit von $2. Kein menschliches Eingreifen. Gleiche Prompts, gleiches Modell, gleiche Rahmenbedingungen. Die einzige Variable war, ob Superpowers aktiviert war.

Das kam dabei heraus:

Kosten- und Token-Effizienz

Die durchschnittlichen Kosten über die 6 Superpowers-Sitzungen lagen etwa 9 % niedriger als bei den 6 Baseline-Sitzungen. Das ist bares Geld, wenn man täglich Dutzende Sitzungen fährt, aber es sind nicht die dramatischen Einsparungen, die manche Reviews versprechen.

Die Token-Bilanz ist differenzierter. Insgesamt verbrauchten Superpowers-Sitzungen im Schnitt etwa 14 % weniger Tokens. Doch dieser Durchschnitt verschleiert ein entscheidendes Muster:

Einfache Aufgaben verbrauchten mit Superpowers tatsächlich mehr Tokens. Die Phasen „Klären“ und „Design“ verursachten einen Overhead, den eine simple „Schreib mir eine Utility-Funktion“-Aufgabe schlicht nicht braucht. Das Framework stellte klärende Fragen zu einem Problem, das keinerlei Unklarheiten aufwies. Es plante eine Architektur für etwas, das in eine einzige Datei gehörte. Die Disziplin war echt – aber für ein 50-Zeilen-Skript ist das zu viel des Guten.

Mittlere Aufgaben lagen beim Token-Verbrauch etwa gleichauf, lieferten aber messbar besseren Code. Der Planungs-Overhead wurde durch weniger Korrekturrunden später ausgeglichen.

Komplexe Aufgaben zeigten deutliche Token-Einsparungen – und hier verdient sich Superpowers seinen Ruf. Die Planungsphasen (Klären, Design, Planen) verbrauchten nur minimale Tokens – fast nur Text, keine Code-Generierung. Aber sie verhinderten das teure Scheitern, das ich zuvor beschrieben habe: Tausende Zeilen Code zu schreiben, die das falsche Problem lösen. Ohne Superpowers lösten komplexe Aufgaben häufig mehrere Neustart-Zyklen aus. Mit Superpowers traf der Agent beim ersten Implementierungsversuch viel öfter ins Schwarze.

Die Varianz-Entdeckung, die meine Meinung änderte

Hier ist der Datenpunkt, der mich tatsächlich vom Skeptiker zum täglichen Nutzer gemacht hat.

Die Varianz beim Token-Verbrauch über die 6 Superpowers-Sitzungen war 2–3x niedriger als bei den Baseline-Sitzungen. Anders gesagt: Ohne Superpowers waren meine komplexen Aufgaben völlig unberechenbar. Eine Sitzung kostete $0,80, die nächste erreichte bei einer ähnlichen Aufgabe das $2-Limit. Mit Superpowers lagen die Sitzungen eng beieinander, was die Kosten anging.

Warum ist das wichtig? Weil Vorhersagbarkeit ihren Preis wert ist. Wenn ich ein Projekt abstecke und die KI-gestützten Entwicklungskosten schätzen will, muss ich ungefähr wissen, was ein Feature an Tokens kosten wird. Superpowers machte diese Schätzung zuverlässig. Die Baseline-Sitzungen waren im Grunde ein Münzwurf.

API-Roundtrips

Superpowers-Sitzungen machten im Schnitt weniger API-Roundtrips. Das ist logisch – weniger Korrekturrunden bedeuten weniger Hin-und-Her. Jeder Roundtrip bringt Latenz und Token-Overhead mit sich, also summieren sich weniger Durchläufe zu echten Kosteneinsparungen und schnelleren Durchlaufzeiten.

Code-Qualitäts-Scores

Ich habe die Ergebnisse jeder Sitzung in vier Dimensionen bewertet: Korrektheit, Code-Struktur, Testabdeckung und Fehlerbehandlung. Superpowers-Sitzungen erzielten messbar höhere Werte bei Korrektheit, Struktur und Testabdeckung. Besonders auffällig war die Verbesserung bei der Testabdeckung – die eingebaute TDD-Fähigkeit sorgt dafür, dass Tests zuerst geschrieben werden, nicht nachträglich angehängt (oder ganz weggelassen, wie es in den meisten Baseline-Sitzungen passiert).

Eine überraschende Beobachtung: Die Robustheit – also wie gut der Code mit Randfällen und unerwarteten Eingaben umging – war in den Baseline-Sitzungen minimal besser. Meine Vermutung? Der strukturierte Ansatz optimiert manchmal zu sehr auf den geplanten Happy Path. Ohne Framework hat der Agent gelegentlich Randfälle freier erkundet, weil er keinem vorgegebenen Plan folgte. Das ist ein echter Trade-off, den man kennen sollte.

Ich möchte transparent mit den Grenzen dieses Experiments umgehen. Zwölf Sitzungen sind keine statistisch signifikante Stichprobe. Die Aufgaben wurden von mir entworfen, was meine eigenen Vorurteile einbringt. Und entscheidend: Das Experiment lief vollautomatisch – aber Superpowers ist für menschliche Iteration im Loop konzipiert. Die klärenden Fragen, die Designauswahl, die Planüberprüfung – das sind Interaktionspunkte, bei denen der Input eines Entwicklers das Framework deutlich effektiver macht. Mein automatisierter Test hat all das umgangen.

Betrachten Sie meine Zahlen als Richtungsanzeiger, nicht als Evangelium. Die echten Vorteile entstehen, wenn man aktiv mit dem Framework zusammenarbeitet, nicht wenn man es einfach im Autopilot laufen lässt.

Apropos Zusammenarbeit – ich zeige Ihnen jetzt, wie Installation und tägliche Nutzung tatsächlich aussehen.

Superpowers installieren: Schneller als gedacht

Die Installation dauert etwa 30 Sekunden. Es gibt zwei Wege:

Option 1: Claude Plugins Marketplace

Wenn du Claude Code mit Marketplace-Zugang nutzt, ist das der einfachste Weg:

/plugin install superpowers@claude-plugins-official

Ein Befehl. Fertig. Superpowers ist in allen deinen Claude-Code-Sitzungen aktiv.

Option 2: Direkt von GitHub

Wenn du lieber aus dem Quellcode installierst oder die Skills anpassen möchtest:

# Repository klonen
git clone https://github.com/obra/superpowers.git

# Global auf Benutzerebene installieren (empfohlen)
claude plugins install --global ./superpowers

Jesse empfiehlt, global auf Benutzerebene zu installieren statt projektbezogen. Ich stimme zu – du willst die Methodik überall verfügbar haben, nicht nur in bestimmten Repositories. Die Skills sind allgemein genug, um jeden Coding-Workflow zu verbessern.

Option 3: VS Code Terminal

Wenn du Claude Code über das VS Code Terminal verwendest (was ich wegen der besseren Übersicht bevorzuge):

# VS Code Terminal öffnen und ausführen
claude plugin add obra/superpowers

Nach der Installation läuft Superpowers automatisch im Hintergrund. Du musst es nicht explizit aufrufen. Die zentrale „Using Superpowers“-Skill fängt deine Anfragen ab und leitet sie durch die passenden Phasen. Wenn du auf Nummer sicher gehen willst, kannst du „use any relevant superpower skills“ zu deinen Prompts hinzufügen – aber meiner Erfahrung nach ist die automatische Erkennung zuverlässig genug, dass das nicht nötig ist.

Was mir besonders gefallen hat: Superpowers kommt anderen Skills oder Plugins, die du bereits installiert hast, nicht in die Quere. Ich nutze es parallel zu meinen individuellen SEO-Skills und mehreren projektspezifischen Skills – ohne Konflikte. Der Orchestrator ist intelligent genug, um zu erkennen, wann eine andere Skill die Anfrage übernehmen sollte.

Falls du möchtest, dass jemand deine komplette Claude-Code-Entwicklungsumgebung einrichtet – Superpowers, individuelle Skills, projektspezifische Konfigurationen – übernehme ich solche Aufträge. Was ich bereits gebaut habe, findest du unter fiverr.com/s/EgxYmWD.

Kommen wir nun zu dem Feature, das mich beim Testen am meisten überrascht hat.

Der visuelle Begleiter: Warum ich vom Skeptiker zum Befürworter wurde

Ich habe den visuellen Begleiter in den ersten beiden Sitzungen als Spielerei abgetan. Interaktive Dashboards? Kraftdiagramme? Kartenraster? Das fühlte sich wie UI-Zucker an, der auf einen eigentlich terminalbasierten Workflow gestreut wurde.

Dann stieß ich auf eine komplexe Aufgabe – ein Multi-Tenant-SaaS-Feature mit rollenbasierter Zugriffskontrolle, Audit-Logging und einem eigenen Berechtigungssystem. Eine dieser Anforderungen, die man auf drei verschiedene Arten interpretieren kann, wobei jede Interpretation zu einer grundlegend anderen Architektur führt.

Superpowers generierte einen visuellen Begleiter, der drei Designansätze als interaktive Karten darstellte. Jede Karte zeigte die Architektur visuell – Datenmodelle, API-Endpunkte, Komponentenhierarchie, Berechtigungsfluss. Ich konnte die Vor- und Nachteile auf einen Blick erkennen. Option A war einfacher, würde aber nicht über 50 Mandanten hinaus skalieren. Option B bewältigte die Skalierung, brachte jedoch erhebliche Datenbankkomplexität mit sich. Option C lag mit einer Caching-Schicht dazwischen.

Ohne den visuellen Begleiter wäre Folgendes passiert: Claude wählt die Interpretation, die ihm „am wahrscheinlichsten“ erscheint, programmiert das gesamte Feature, und ich entdecke das architektonische Missverständnis nach 2.000 Zeilen Code. Mit dem visuellen Begleiter habe ich die richtige Herangehensweise in etwa 45 Sekunden erkannt und der Agent hat beim ersten Versuch genau das gebaut, was ich brauchte.

Die klärenden Rückfragen funktionieren ähnlich. Superpowers fragt nicht einfach nur „Möchten Sie Feature X?“ Es bringt die spezifischen Unklarheiten in Ihrer Anfrage ans Licht, die ein Senior Developer auch in einem Code-Review ansprechen würde. In einer Sitzung fragte mich das Tool, ob meine Anforderung „Benutzerauthentifizierung“ eine sitzungsbasierte Authentifizierung, JWT-Tokens oder OAuth2 meint – und erklärte dann die jeweiligen Auswirkungen auf die restliche Architektur. Ich hatte das nicht spezifiziert, weil ich noch gar nicht darüber nachgedacht hatte. Diese eine Frage sparte einen kompletten Implementierungszyklus.

Das ist das Human-in-the-Loop-Design, das ich zuvor erwähnt habe. Das Framework ist genau für diese Interaktionsmomente konzipiert. Überspringt man sie (wie mein automatisierter Test es tat), verliert man einen erheblichen Teil des Mehrwerts.

Die 14 Skills: Was jeder Einzelne tatsächlich tut

Die meisten Reviews listen die Skills nur auf, ohne zu erklären, wann sie ausgelöst werden oder warum sie wichtig sind. Hier ist die Aufschlüsselung basierend auf meinen Beobachtungen während des Tests:

Der Orchestrator

Using Superpowers — Der Master-Dispatcher. Er liest jede Eingabe, die du sendest, und entscheidet, welche Skills aktiviert werden. Das läuft bei jeder Interaktion automatisch. Du rufst ihn nie direkt auf; er ist der Verkehrslotsen.

Design-Phase-Skills

Brainstorming — Generiert Designoptionen mit visuellen Begleitern. Erstellt detaillierte Checklisten, die die Planungsphase als Input nutzt. Dieser Skill wird ausgelöst, bevor irgendeine Implementierungsarbeit beginnt, und ist verantwortlich für die interaktiven Kartenraster und Kraftdiagramme, die ich oben beschrieben habe.

Planungs-Phase-Skills

Writing Plans — Erstellt hyperdetaillierte Implementierungspläne. Jeder Plan zerlegt die Arbeit in Aufgaben, die auf 2–5 Minuten geschätzt werden, enthält exakte Dateipfade und Funktionssignaturen, spezifiziert Abhängigkeiten zwischen Aufgaben und wird als referenzierbares Dokument gespeichert. Ich habe begonnen, diese gespeicherten Pläne als schlanke technische Spezifikationen für meine Projekte zu verwenden.

Executing Plans — Nimmt einen geschriebenen Plan und koordiniert die Ausführung. Hier greift die Subagenten-Architektur: Der Skill startet für jede Aufgabe im Plan frische Claude-Code-Agenten, verwaltet deren Ergebnisse und integriert die erledigten Aufgaben.

Ausführungs-Phase-Skills

Subagent-Driven Development — Startet unabhängige Subagenten für parallele Aufgabenausführung. Wenn dein Plan drei Aufgaben ohne gegenseitige Abhängigkeiten enthält, werden alle drei gleichzeitig ausgeführt. Der Geschwindigkeitsgewinn bei komplexen Projekten ist spürbar — die tatsächliche Laufzeit sinkt deutlich, wenn unabhängige Aufgaben nicht aufeinander warten müssen.

Dispatching Parallel Agents — Die Koordinationsschicht für parallele Ausführung. Verwaltet den Status über gleichzeitige Subagenten hinweg, stellt sicher, dass erledigte Aufgaben nicht kollidieren, und übernimmt das Zusammenführen paralleler Ergebnisse.

Quality-Gate-Skills

Test-Driven Development — Dieser Skill erzwingt die TDD-Methodik: Zuerst fehlschlagende Tests schreiben, dann minimalen Code, um sie zu bestehen, anschließend refaktorieren. In meinen Tests war dies der größte Beitrag zu besseren Code-Qualitätswerten. Ohne diesen Skill schreibt Claude Code zuerst Implementierungscode und dann (wenn überhaupt) Tests. Mit TDD beginnt jede Funktion mit einer klaren Definition von „fertig“ in Form ausführbarer Tests.

Systematic Debugging — Wenn etwas schiefgeht, erzwingt dieser Skill ein vierphasiges Debugging-Protokoll: Ursachenanalyse, Analyse verwandter Systeme, Hypothesenbildung und Test der Korrektur. Er verhindert das „Schrotflinten-Debugging“, bei dem der Agent wahllos Änderungen macht, in der Hoffnung, dass etwas funktioniert. Ich habe erlebt, wie dieser Skill ganze Sessions gerettet hat, die sonst in tokenfressenden Fix-Schleifen geendet hätten.

Verification Before Completion — Das finale Quality Gate. Bevor Superpowers irgendeine Arbeit als abgeschlossen erklärt, verlangt dieser Skill das Ausführen der Testsuite, die Überprüfung, dass alle Anforderungen aus der Klarifizierungsphase erfüllt sind, und die Bestätigung, dass der Code kompiliert und läuft. Kein „Ich bin fertig“, gefolgt von sofortigen Fehlern mehr.

Code-Review-Skills

Requesting Code Review — Wird ausgelöst, wenn die Implementierung abgeschlossen ist. Führt ein strukturiertes Review durch, das Korrektheit, Stil, Performance und Sicherheit prüft, bevor der Code übernommen wird.

Receiving Code Review — Geht mit Feedback aus Code-Reviews um, wie Jesse es nennt, mit „technischer Strenge, nicht performativer Zustimmung“. Der Skill bewertet Review-Kommentare kritisch, statt jede Anmerkung blind umzusetzen. Das verhindert, dass Review-Feedback den Code verschlechtert, weil der Agent schlechten Vorschlägen nicht widerspricht.

Git-Workflow-Skills

Using Git Worktrees — Erstellt isolierte Git-Worktrees für die Feature-Entwicklung. Hält deinen Hauptarbeitsbereich sauber, während Experimente in separaten Branches laufen. Intelligente Verzeichnisauswahl und Sicherheitsüberprüfung verhindern das Worktree-Chaos, das bei manueller Git-Worktree-Verwaltung oft entsteht.

Finishing a Development Branch — Führt den Abschluss der Entwicklungsarbeit, indem strukturierte Optionen präsentiert werden: Merge in main, PR erstellen oder Branch aufräumen. Das verhindert das übliche Problem, halbfertige Branches im Repository liegenzulassen.

Der Meta-Skill

Writing Skills — Das ist der Skill, der AI-Framework-Enthusiasten begeistert. Superpowers kann neue Superpowers-Skills nach TDD-Prinzipien schreiben. Du beschreibst die gewünschte Fähigkeit, und das Framework erstellt einen getesteten, verifizierten Skill, der sich in das restliche System integriert. Das Framework erweitert sich selbst. Ich habe damit projektspezifische Skills erstellt, die Superpowers-Konventionen folgen und sich in die Orchestrierungs-Schicht einfügen.

Die ehrliche Einschätzung: Wo Superpowers Schwächen zeigt

Jede Rezension, die ich über Superpowers gelesen habe, konzentriert sich auf die Erfolge. Das hier verschweigen sie Ihnen.

Einfache Aufgaben werden langsamer, nicht schneller. Wenn Sie eine schnelle Utility-Funktion, ein einmaliges Skript oder ein simples Refactoring brauchen, sorgt der Overhead aus Klarstellung, Design und Planung für zusätzliche Zeit – ohne Mehrwert. Ich habe angefangen, einfache Anfragen mit „quick task, skip planning:“ zu beginnen, und der Orchestrator hält sich meistens daran. Aber standardmäßig unterscheidet Superpowers nicht zwischen einem 10-Zeilen-Fix und einem 10.000-Zeilen-Feature. Die vollständige Methodik wird auf beides angewendet.

Domänenwissen verbessert sich nicht. Superpowers macht Claude disziplinierter, aber nicht wissender. Wenn das Modell Ihr spezifisches Framework, Ihre Geschäftsdomain oder Ihre proprietären APIs nicht versteht, kann Superpowers das nicht beheben. Es plant lediglich sorgfältiger um die Wissenslücken herum – was besser ist, als blind zu programmieren, aber die Lücken bleiben bestehen. Sie müssen weiterhin domänenspezifischen Kontext in Ihre Prompts oder die CLAUDE.md einbringen.

Spezifikationskonformität bleibt unverändert. Wenn Ihre Anforderungen falsch oder unvollständig sind, plant und setzt Superpowers diese Anforderungen genauso um – auch wenn sie falsch oder unvollständig sind. Die klärenden Fragen helfen – sie decken einige Lücken auf –, aber sie ersetzen keine gut geschriebene Spezifikation. Ich habe beobachtet, wie das Framework ein perfekt geplantes, perfekt ausgeführtes Feature gebaut hat, das exakt das war, was ich verlangt hatte – und völlig an meinem eigentlichen Bedarf vorbeiging. Die Methodik ist nur so gut wie die Inputs, die sie erhält.

Token-Spitzen treten auf. In einer Sitzung habe ich festgestellt, dass Superpowers während der Brainstorming-Phase aggressiv Tokens verbrauchte und einen aufwendigen Design-Companion für eine Aufgabe generierte, die das nicht rechtfertigte. Die GitHub-Issues bestätigen, dass das kein Einzelfall ist – Issue #953 im Repository beschreibt ein ähnliches Muster. Es ist selten, aber es kommt vor, und wenn Sie mit einem knappen Token-Budget arbeiten, sollten Sie das wissen.

Die Lernkurve ist für Teams real. Für Solo-Entwickler funktioniert Superpowers sofort. Wenn Sie das Tool im Team einführen wollen, sollten Sie mit Rückfragen rechnen. Die visuellen Begleiter verwirren Entwickler, die nur mit dem Terminal arbeiten. Die klärenden Fragen frustrieren Entwickler, die „einfach nur Code wollen“. Die TDD-Vorgaben nerven Entwickler, die keine Tests schreiben (und auch nicht damit anfangen wollen). Die Einführung erfordert Zustimmung, nicht nur Installation.

Das sind keine K.-o.-Kriterien. Es sind Trade-offs. Und wenn Sie sie im Vorfeld kennen, können Sie entscheiden, ob sich der Kompromiss für Ihre Situation lohnt.

Wann Sie Superpowers verwenden sollten (und wann nicht)

Nach einem Monat täglicher Nutzung ist hier mein Entscheidungsrahmen:

Verwenden Sie Superpowers, wenn:

• Die Aufgabe mehrere Dateien, Dienste oder Architekturentscheidungen umfasst
• Sie ein Feature entwickeln, das in bestehenden Code integriert werden muss
• Die Anforderungen so unklar oder komplex sind, dass sie leicht missverstanden werden können
• Ihnen Testabdeckung und Code-Struktur wichtig sind, nicht nur „läuft es?“
• Sie Projektkosten abschätzen und einen vorhersehbaren Token-Verbrauch benötigen
• Sie an einem Codebase arbeiten, das Sie langfristig warten werden

Lassen Sie Superpowers aus, wenn:

• Sie ein schnelles, einmaliges Skript oder Utility benötigen
• Die Aufgabe ein einfacher Bugfix mit offensichtlicher Lösung ist
• Sie explorieren oder prototypisieren und keinen Planungs-Overhead möchten
• Das Token-Budget extrem knapp ist und die Aufgabe unkompliziert ist

Der Sweet Spot — also der Bereich, in dem Superpowers den größten Mehrwert pro eingesetztem Token liefert — sind mittel- bis komplexe Aufgaben in aktiven, gepflegten Codebasen. Hier verhindert die Planung teure Nacharbeiten, TDD fängt Regressionen ab und die Sub-Agenten-Architektur beschleunigt die parallele Umsetzung.

Superpowers vs. die Alternativen: Schneller Vergleich

Superpowers ist nicht das einzige strukturierte Framework für Claude Code. Zwei bemerkenswerte Alternativen sind GSD (Get Stuff Done) und gstack. So unterscheiden sie sich auf hoher Ebene:

Die Frage ist nicht „Was ist das Beste?“, sondern „Was passt zu deiner Aufgabe?“. Ich nutze Superpowers standardmäßig und deaktiviere es gelegentlich für schnelle Aufgaben, bei denen der schlanke Ansatz von GSD besser geeignet ist. Es sind ergänzende Werkzeuge, keine Konkurrenten.

Was das für meine Arbeitsweise jetzt bedeutet

Nach einem Monat hat Superpowers meinen Claude-Code-Workflow auf drei ganz bestimmte Arten verändert.

Erstens habe ich aufgehört, Claude Code als Code-Generator zu betrachten, und angefangen, ihn als Entwicklungspartner zu sehen. Die Phasen „Klarheit schaffen“ und „Design“ erzwingen ein Gespräch, das es vorher nicht gab. Meine Prompts sind kürzer und fokussierter geworden, weil ich weiß, dass das Framework die richtigen Anschlussfragen stellt. Ich versuche nicht mehr, alle Anforderungen in einen einzigen Prompt zu packen.

Zweitens hat sich meine Genauigkeit bei der Projektabschätzung verbessert. Durch den vorhersehbaren Token-Verbrauch kann ich KI-unterstützte Features mit Zuversicht einschätzen. „Dieses Feature wird ungefähr X Tokens zur Implementierung benötigen“ ist jetzt eine Aussage, die ich mit vertretbarer Genauigkeit treffen kann. Vor Superpowers war diese Schätzung so ungenau, dass man einen LKW durch die Fehlerbalken fahren konnte.

Drittens – und das hat mich überrascht – schreibe ich bessere Spezifikationen. Die klärenden Fragen haben mir gezeigt, welche Informationen der Agent tatsächlich braucht und was ich bisher nur aus Gewohnheit beigefügt habe. Meine Spezifikationen sind kürzer, präziser und führen zu weniger Iterationen. Das Framework hat mich genauso trainiert wie den Agenten.

Ist Superpowers das richtige Tool für alle? Nein. Wenn du einfache Aufgaben erledigst, prototypisierst oder in einem Bereich arbeitest, in dem sich Planungsaufwand nicht lohnt, wird es dich eher ausbremsen. Aber wenn du echte Software baust – Features, die funktionieren, integriert und gewartet werden müssen – dann ist die Disziplin der fünf Phasen kein Overhead. Sie ist der Weg, wie professionelle Software entsteht. Das Framework erzwingt nur das, was gute Entwickler ohnehin tun – und gibt es einer KI, die diese Struktur dringend gebraucht hat.

Die 121.000 GitHub-Sterne sind kein Hype. Das sind 121.000 Entwickler, die an dieselbe Wand gestoßen sind wie ich – brillante KI, null Disziplin – und die dieselbe Antwort gefunden haben.

Installiere es. Setze es bei deiner nächsten komplexen Aufgabe ein. Und entscheide dann selbst. Genau das habe ich getan – und das Experiment hat lauter gesprochen als jede Rezension.

Häufig gestellte Fragen

Funktioniert Superpowers mit allen Claude Code-Modellen?

Superpowers funktioniert mit jedem Modell, das über Claude Code verfügbar ist, einschließlich Opus 4.6 und Sonnet 4.6. Die Skills sind modellunabhängig – sie verändern den Workflow, nicht die zugrundeliegenden Modellfähigkeiten. Leistungsverbesserungen skalieren mit der Modellkapazität, daher zeigen Opus-Sitzungen in der Regel größere Qualitätsgewinne als Sonnet-Sitzungen.

Wie deaktiviere ich Superpowers für einfache Aufgaben?

Stellen Sie Ihrem Prompt „quick task“ oder „skip planning“ voran, und der Orchestrator überspringt in der Regel den vollständigen Klarstellen-Design-Planungs-Zyklus. Sie können das Plugin auch vorübergehend mit /plugin disable superpowers deaktivieren und mit /plugin enable superpowers wieder aktivieren. Für eine feinere Steuerung lassen sich einzelne Skills in den Plugin-Einstellungen ein- und ausschalten.

Kommt es zu Konflikten zwischen Superpowers und anderen Claude Code-Plugins oder Skills?

In meinen Tests über vier Monate täglicher Nutzung hinweg koexistiert Superpowers problemlos mit anderen Plugins und benutzerdefinierten Skills. Der Orchestrator ist so konzipiert, dass er erkennt, wann eine andere Fähigkeit eine Anfrage bearbeiten sollte, und tritt dann entsprechend zurück. Sollten dennoch Konflikte auftreten, überprüfen Sie, ob Ihre anderen Skills keine überlappenden Auslösebedingungen mit den Kernphasen von Superpowers definieren.

Ist Superpowers kostenlos?

Ja. Superpowers ist vollständig Open Source unter der MIT-Lizenz und wird auf github.com/obra/superpowers gehostet. Es gibt keine kostenpflichtigen Stufen, keine Premium-Funktionen, keine Nutzungslimits. Das gesamte Framework – alle 14 Skills – ist kostenlos installierbar, nutzbar und modifizierbar.

Wie stark reduziert Superpowers die Token-Kosten?

Basierend auf meinem 12-Sitzungen-Experiment: durchschnittlich etwa 9 % Kostenreduktion und 14 % weniger Token, wobei die Einsparungen sich auf mittlere und komplexe Aufgaben konzentrieren. Bei einfachen Aufgaben kann der Planungsaufwand tatsächlich zu einem höheren Tokenverbrauch führen. Der wertvollere Messwert ist die Konsistenz – die Varianz beim Tokenverbrauch sank um das 2- bis 3-fache, was die Kostenschätzung für Projekte deutlich zuverlässiger macht.

Lassen Sie uns zusammenarbeiten

Sie möchten KI-Systeme entwickeln, Workflows automatisieren oder Ihre technische Infrastruktur skalieren? Ich unterstütze Sie gerne dabei.

• Fiverr (individuelle Lösungen & Integrationen): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (Enterprise-Lösungen): ramlit.com
• ColorPark (Design & Branding): colorpark.io
• xCyberSecurity (Sicherheitsdienstleistungen): xcybersecurity.io