Ik testte Superpowers voor Claude Code — dit is mijn oordeel

Ik stond op het punt Superpowers te negeren. Weer een skills-framework, weer een GitHub-repository die belooft mijn AI-coding workflow te “revolutioneren”. Ik had er al tientallen zien komen en gaan — flitsende READMEs, indrukwekkende demo’s, na drie maanden verlaten. Dus toen Jesse Vincent’s framework sneller GitHub-sterren verzamelde dan wat ik ooit in het Claude Code-ecosysteem had gezien, was mijn eerste reactie scepsis.

Toen deed ik een experiment. Twaalf Claude Code-sessies, zes met Superpowers geïnstalleerd, zes zonder. Dezelfde taken. Dezelfde prompts. Een bestedingslimiet van $2 per run. Geen enkele menselijke tussenkomst — volledig geautomatiseerd, zodat mijn eigen vooroordelen de resultaten niet konden beïnvloeden.

De cijfers vertelden een verhaal dat ik niet had verwacht. Niet het “10x productiever”-verhaal dat de hype je wil doen geloven. Iets genuanceerders, bruikbaarders, en eerlijk gezegd interessanters. Superpowers maakte Claude niet slimmer. Het maakte Claude gedisciplineerd — en het verschil tussen intelligentie en discipline bleek precies de kloof waar ik al maanden mee worstelde zonder het te beseffen.

Hier is alles wat ik ontdekte, inclusief de onderdelen die de meeste reviews handig overslaan.

Ik testte Superpowers voor Claude Code — dit is mijn oordeel

Als je serieus met Claude Code hebt gewerkt, herken je dit patroon. Je beschrijft wat je wilt. Claude begint direct met code schrijven. Vijftien minuten en 40.000 tokens later besef je dat hij je eisen al in de eerste dertig seconden verkeerd begreep. De hele output is technisch correcte code die het verkeerde probleem oplost.

Ik hield dit het afgelopen kwartaal bij in mijn eigen projecten. Ongeveer 35% van mijn Claude Code-sessies vereiste minstens één grote koerscorrectie — niet omdat het model dom was, maar omdat het direct naar implementatie sprong zonder even stil te staan. Geen requirements gathering. Geen architectuuroverweging. Geen plan. Gewoon code, code, code, en hopen op het beste.

Klinkt bekend? Je bent niet de enige. Dit is het standaardgedrag van elke coding agent die ik heb getest. Ruwe intelligentie zonder methodiek. Het is alsof je een briljante engineer inhuurt die weigert de specificaties te lezen voordat hij de eerste regel schrijft.

Jesse Vincent — de Perl-projectleider en Keyboardio-oprichter die Superpowers bouwde — herkende precies deze faalmodus. Zijn oplossing was niet om het model slimmer te maken. Het was om dezelfde discipline op te leggen die een senior engineering lead van een junior developer zou eisen: stop, denk na, maak een plan, en dan bouwen.

Dat onderscheid is belangrijker dan welk individueel feature in het framework dan ook. En het begrijpen ervan is de sleutel om te weten of Superpowers je workflow daadwerkelijk zal verbeteren of alleen maar extra ballast toevoegt.

Maar voordat ik in de architectuur duik, moet je begrijpen hoe dit framework van een niche GitHub-repo naar 121.000 sterren in een paar maanden tijd groeide — want die opmars zegt iets belangrijks over een pijnpunt dat de hele community voelde.

Van Zijproject tot 121.000 GitHub-sterren

Superpowers werd niet gelanceerd met een marketingcampagne. Jesse Vincent publiceerde het op GitHub als obra/superpowers, omschreef het als "een agentisch skills-framework & softwareontwikkelmethode die werkt," en liet het verder voor wat het was. De eerste gebruikers waren ontwikkelaars die zijn werk bij Keyboardio en in de Perl-community al volgden.

Toen gebeurde er iets. De repo begon op zijn hoogtepunt bijna 2.000 sterren per dag te verzamelen. In januari 2026 werd het officieel toegelaten tot de Claude plugins-marktplaats door Anthropic. In maart was de grens van 94.000 sterren gepasseerd. In april 2026 staat de teller op meer dan 121.000 — waarmee het een van de snelst groeiende open-sourceprojecten van het jaar is, en de #2 trending positie op GitHub veiligstelde.

Waarom? Omdat Jesse geen tool verkocht. Hij formuleerde een methode die aansloot bij wat ervaren ontwikkelaars al wisten, maar niet konden afdwingen bij hun AI-agents: je plant voordat je bouwt. Je test voordat je levert. Je verifieert voordat je het af noemt.

Het framework was slechts het voertuig voor die methode. En zodra ontwikkelaars het probeerden, verspreidde het nieuws zich vanzelf.

Ik hoorde er voor het eerst over via een collega die zei dat de codekwaliteit bij zijn eerste poging met ongeveer 40% was gestegen na een week werken met Superpowers. Ik was sceptisch over dat getal. Na mijn eigen tests denk ik dat het voor complexe taken zelfs aan de voorzichtige kant is — en voor eenvoudige taken juist flink overdreven. De werkelijkheid is, zoals gewoonlijk, complexer dan één enkel percentage.

Laat me je zien wat er daadwerkelijk in de doos zit.

Wat Superpowers Eigenlijk Is (En Wat Niet)

Superpowers is geen enkele vaardigheid. Het is een systeem — 14 onderling verbonden skills die je installeert in Claude Code en samen een complete softwareontwikkelworkflow aansturen. Zie het minder als het installeren van een plugin en meer als het onboarden van een senior engineeringproces in je agent.

Het framework dwingt vijf fasen af bij elke interactie:

Clarify — Voordat er ook maar één regel code wordt geschreven, stelt de agent vragen. Geen generieke “wat wil je?”-vragen. Specifieke, gerichte verduidelijkingen die bedoeld zijn om de onduidelijkheden in je verzoek naar boven te halen die anders later bugs zouden worden. In mijn tests ving deze fase ongeveer 60% van de requirement-gaten die ik zelf in mijn prompt niet had opgemerkt.

Design — Hier wordt Superpowers echt interessant. De agent genereert visuele hulpmiddelen — interactieve dashboards met force graphs, kaartroosters en optielay-outs — zodat je de architectuur kunt zien voordat je eraan vastzit. Je kiest uit meerdere ontwerpbenaderingen, en de agent gebruikt jouw keuze om de bouw te sturen. Eerlijk: de eerste keer dat ik dit zag, vond ik het gimmicky. Bij de derde sessie was ik verkocht. De architectuur visueel zien vóórdat je begint met coderen, elimineert een hele categorie misverstanden.

Plan — De agent maakt hypergedetailleerde implementatieplannen. Geen vage outlines — echte taakopdelingen met geschatte voltooiingstijden van 2-5 minuten, exacte bestandslocaties, specifieke functienamen en afhankelijkheidsvolgorde. Deze plannen worden opgeslagen voor later, dus als je sessie crasht of je wilt later verdergaan, ligt de roadmap al klaar.

Code — Hier betaalt de methodologie zich uit. In plaats van één monolithische codeersprint, splitst Superpowers de uitvoering op in afzonderlijke taken en start voor elke taak een nieuwe sub-agent. Onafhankelijke taken kunnen parallel worden uitgevoerd. Elke taak heeft veiligheidsstops — checkpoints waar de agent pauzeert om te controleren of hij nog op koers ligt voordat hij doorgaat. Door deze sub-agentarchitectuur betekent een mislukking in één taak niet dat de hele sessie wordt besmet.

Verify — De laatste fase draait test suites, controleert of alle requirements uit de clarify-fase zijn gehaald, en valideert de codestructuur voordat het werk als voltooid wordt beschouwd.

De master skill — genaamd “Using Superpowers” — fungeert als orkestrator. Elke keer dat je een Claude Code-interactie start, leest deze je verzoek en beslist welke van de 14 skills moet worden ingezet. Je triggert de fasen niet handmatig. Het systeem regelt de routing automatisch.

Wat Superpowers niet is: het is geen prompttemplate. Het is geen CLAUDE.md-bestand vol instructies. De skills zijn uitvoerbare, samenstelbare modules die testgedreven ontwikkeling afdwingen, systematische debugprotocollen bevatten en — dit verraste mij — een meta-skill waarmee Claude nieuwe Superpowers-skills kan schrijven volgens TDD-principes. Het framework kan zichzelf uitbreiden.

Als je mijn artikelen over agent skills architecture hebt gevolgd, herken je hier het patroon van progressive disclosure. Superpowers dumpt niet alle 14 skills tegelijk in het contextvenster. De orkestrator laadt alleen de relevante skill voor elke fase, waardoor het tokengebruik beperkt blijft. Die ontwerpkeuze is een groot deel van de reden waarom het framework daadwerkelijk tokens bespaart in plaats van ze te verspillen aan overhead.

En dan over die tokenbesparing — hier moet ik eerlijk zijn over wat de cijfers daadwerkelijk laten zien.

Het 12-Sessies Experiment: Wat de Cijfers Echt Zeggen

Ik wilde echte data, geen onderbuikgevoel. Dus ontwierp ik een gecontroleerde vergelijking: 12 Claude Code-sessies, 6 met Superpowers ingeschakeld, 6 zonder. Elke batch bestond uit twee eenvoudige taken (single-file utilities), twee middelzware taken (multi-file features met API-integratie) en twee complexe taken (full-stack features met database-schemawijzigingen, authenticatie en UI-componenten).

Elke sessie had een bestedingslimiet van $2. Geen enkele menselijke tussenkomst. Dezelfde prompts, hetzelfde model, dezelfde beperkingen. De enige variabele was of Superpowers actief was.

Dit kwam eruit:

Kosten- en Token-efficiëntie

De gemiddelde kosten over de 6 Superpowers-sessies lagen ongeveer 9% lager dan bij de 6 baseline-sessies. Dat is echt geld als je dagelijks tientallen sessies draait, maar het zijn niet de spectaculaire besparingen die sommige reviews beloven.

Het verhaal rond tokens is genuanceerder. Over het geheel genomen gebruikten Superpowers-sessies gemiddeld zo’n 14% minder tokens. Maar dat gemiddelde verbergt een cruciaal patroon:

Eenvoudige taken gebruikten juist meer tokens met Superpowers. De clarify- en design-fases voegden overhead toe die een simpele “schrijf een utility-functie”-taak helemaal niet nodig heeft. Het framework stelde verhelderende vragen over een probleem zonder enige ambiguïteit. Het plande een architectuur voor iets dat in één bestand thuishoorde. De discipline was oprecht — maar voor een script van 50 regels is het overdreven.

Middelzware taken kwamen qua tokens ongeveer gelijk uit maar leverden merkbaar betere code op. De planningsoverhead werd gecompenseerd door minder correctierondes achteraf.

Complexe taken lieten aanzienlijke tokenbesparingen zien — en hier verdient Superpowers zijn reputatie. De planningsfases (clarify, design, plan) verbruikten minimale tokens — vrijwel alleen tekst, geen codegeneratie. Maar ze voorkwamen de dure faalmodus die ik eerder beschreef: duizenden regels code schrijven die het verkeerde probleem oplossen. Zonder Superpowers veroorzaakten complexe taken vaak meerdere herstartcycli. Met Superpowers kreeg de agent het veel vaker in één keer goed bij de eerste implementatie.

De Variantie-vondst Die Mijn Mening Veranderde

Dit is het datapunt dat mij daadwerkelijk van scepticus tot dagelijkse gebruiker maakte.

De variantie in tokengebruik over de 6 Superpowers-sessies was 2-3x lager dan bij de baseline-sessies. Anders gezegd: zonder Superpowers waren mijn complexe taken volstrekt onvoorspelbaar. De ene sessie kostte $0,80, de volgende tikte bij een vergelijkbare taak het $2-plafond aan. Met Superpowers lagen de sessies qua kosten dicht bij elkaar.

Waarom is dit belangrijk? Omdat voorspelbaarheid het waard is om voor te betalen. Als ik een project scope en de AI-ontwikkelkosten wil inschatten, moet ik ongeveer weten wat een feature aan tokens gaat kosten. Superpowers maakte die inschatting betrouwbaar. De baseline-sessies waren in feite een muntworp.

API Round Trips

Superpowers-sessies maakten gemiddeld minder API round trips. Dat is logisch — minder correctierondes betekent minder heen-en-weer verkeer. Elke round trip brengt latency en token-overhead met zich mee, dus minder trips levert zowel kostenbesparing als snellere doorlooptijden op.

Codekwaliteitscores

Ik beoordeelde de output van elke sessie op vier dimensies: correctheid, code-structuur, testdekking en foutafhandeling. Superpowers-sessies scoorden merkbaar hoger op correctheid, structuur en testdekking. Vooral de verbetering in testdekking viel op — dankzij de ingebouwde TDD-skill worden tests eerst geschreven, niet achteraf toegevoegd (of helemaal overgeslagen, wat bij de meeste baseline-sessies gebeurt).

Een verrassende bevinding: robuustheid — hoe goed de code omgaat met edge cases en onverwachte input — was marginaal beter in de baseline-sessies. Mijn hypothese? De gestructureerde aanpak optimaliseert soms te veel voor het geplande happy path. Zonder het framework verkende de agent af en toe vrijer de edge cases, omdat hij niet een vooraf bepaald plan volgde. Dit is een reële trade-off om rekening mee te houden.

Ik wil transparant zijn over de beperkingen van dit experiment. Twaalf sessies is geen statistisch significant aantal. De taken zijn door mij ontworpen, wat mijn eigen bias introduceert. En cruciaal: het experiment draaide volledig geautomatiseerd — terwijl Superpowers juist bedoeld is voor iteratie mét menselijke inbreng. De verhelderende vragen, de designkeuze, de planreview — dit zijn interactiemomenten waarbij input van een ontwikkelaar het framework veel effectiever maakt. Mijn geautomatiseerde test sloeg dat allemaal over.

Zie mijn cijfers dus als richtinggevend, niet als absolute waarheid. De echte winst behaal je als je actief samenwerkt met het framework, niet als je het op de automatische piloot laat draaien.

Over samenwerking gesproken — laat me je meenemen in hoe installatie en dagelijks gebruik er in de praktijk uitzien.

Superpowers installeren: Sneller dan je denkt

Installatie duurt ongeveer 30 seconden. Je hebt twee opties:

Optie 1: Claude Plugins Marketplace

Als je Claude Code gebruikt met toegang tot de marketplace, is dit de eenvoudigste route:

/plugin install superpowers@claude-plugins-official

Eén commando. Klaar. Superpowers is direct actief in al je Claude Code-sessies.

Optie 2: Direct vanaf GitHub

Als je liever vanaf de bron installeert of de skills wilt aanpassen:

# Clone de repository
git clone https://github.com/obra/superpowers.git

# Installeer globaal op gebruikersniveau (aanbevolen)
claude plugins install --global ./superpowers

Jesse raadt aan om globaal op gebruikersniveau te installeren in plaats van per project. Daar ben ik het mee eens — je wilt de methodologie overal beschikbaar hebben, niet alleen in specifieke repositories. De skills zijn algemeen genoeg om elke code-workflow te verbeteren.

Optie 3: VS Code Terminal

Gebruik je Claude Code via de VS Code-terminal (wat ik zelf prefereer vanwege het inzicht in de workflow):

# Open de VS Code-terminal en voer uit
claude plugin add obra/superpowers

Na installatie draait Superpowers automatisch op de achtergrond. Je hoeft het niet expliciet aan te roepen. De master-skill "Using Superpowers" onderschept je verzoeken en leidt ze door de juiste fases. Wil je extra zekerheid, dan kun je "use any relevant superpower skills" toevoegen aan je prompts — maar uit mijn ervaring is de automatische detectie betrouwbaar genoeg en is dit niet nodig.

Wat ik waardeer: Superpowers botst niet met andere skills of plugins die je al hebt geïnstalleerd. Ik gebruik het naast mijn custom SEO skills en diverse project-specifieke skills zonder conflicten. De orchestrator is slim genoeg om te herkennen wanneer een andere skill het verzoek moet afhandelen.

Wil je liever dat iemand je hele Claude Code-ontwikkelomgeving opzet — Superpowers, custom skills, project-specifieke configuraties — dan neem ik dit soort opdrachten aan. Bekijk wat ik gebouwd heb op fiverr.com/s/EgxYmWD.

Laten we nu praten over de feature die me het meest verraste tijdens het testen.

De Visuele Companion: Waarom Ik Van Scepticus Tot Bekeerling Ging

Ik deed de visuele companion in de eerste twee sessies af als een gimmick. Interactieve dashboards? Force graphs? Kaartroosters? Dit voelde als UI-saus over wat eigenlijk een terminal-first workflow zou moeten zijn.

Toen kreeg ik een complexe taak — een multi-tenant SaaS-feature met role-based access control, audit logging en een custom permissiesysteem. Zo’n feature waarbij je de requirements op drie verschillende manieren kunt interpreteren, en elke interpretatie leidt tot een fundamenteel andere architectuur.

Superpowers genereerde een visuele companion die drie ontwerpbenaderingen als interactieve kaarten toonde. Elke kaart visualiseerde de architectuur — datamodellen, API-endpoints, componenthiërarchie, permissiestromen. Ik zag de afwegingen in één oogopslag. Optie A was eenvoudiger, maar zou niet verder schalen dan 50 tenants. Optie B kon wel schalen, maar voegde aanzienlijke databasecomplexiteit toe. Optie C zat daar tussenin met een cachinglaag.

Zonder de visuele companion was het volgende gebeurd: Claude kiest de interpretatie die hij het “waarschijnlijkst” acht, codeert alles, en ik ontdek de architecturale mismatch pas na 2.000 regels code. Met de visuele companion zag ik de juiste aanpak in ongeveer 45 seconden, en de agent bouwde precies wat ik nodig had bij de eerste poging.

De verhelderende vragen werken op een vergelijkbare manier. Superpowers vraagt niet alleen “wil je feature X?” Het brengt de specifieke onduidelijkheden in je verzoek naar voren die een senior developer ook zou opmerken tijdens een code review. Tijdens een sessie vroeg het me of mijn “user authentication”-eis betekende: sessiegebaseerde authenticatie, JWT-tokens of OAuth2 — en legde vervolgens de implicaties van elk uit voor de rest van de architectuur. Ik had het niet gespecificeerd omdat ik er nog niet over had nagedacht. Die ene vraag bespaarde een hele implementatiecyclus.

Dit is het human-in-the-loop ontwerp waar ik het eerder over had. Het framework is gemaakt voor precies deze interactiemomenten. Sla je ze over (zoals mijn geautomatiseerde test deed), dan mis je een aanzienlijk deel van de waarde.

De 14 Vaardigheden: Wat Elke Vaardigheid Echt Doet

De meeste reviews sommen de vaardigheden op zonder uit te leggen wanneer ze worden geactiveerd of waarom ze belangrijk zijn. Hier volgt de uiteenzetting op basis van wat ik heb waargenomen tijdens mijn tests:

De Orchestrator

Gebruik van Superpowers — De hoofddispatcher. Deze leest elke prompt die je verstuurt en beslist welke vaardigheden moeten worden ingezet. Dit draait automatisch bij elke interactie. Je roept deze nooit direct aan; het is de verkeersleider.

Ontwerpfase Vaardigheden

Brainstormen — Genereert ontwerpopties met visuele aanvullingen. Produceert gedetailleerde checklists die de planningsfase als input gebruikt. Deze vaardigheid wordt geactiveerd voordat er implementatiewerk begint en is verantwoordelijk voor de interactieve kaartroosters en force graphs die ik hierboven heb beschreven.

Planningsfase Vaardigheden

Plannen Schrijven — Maakt hypergedetailleerde implementatieplannen. Elk plan splitst het werk op in taken van 2-5 minuten, bevat exacte bestandslocaties en functienamen, specificeert afhankelijkheden tussen taken, en wordt opgeslagen als een raadpleegbaar document. Ik gebruik deze opgeslagen plannen inmiddels als lichte technische specificaties voor mijn projecten.

Plannen Uitvoeren — Neemt een geschreven plan en coördineert de uitvoering. Hier komt de subagent-architectuur in beeld — de vaardigheid zet voor elke taak in het plan een nieuwe Claude Code-agent in, beheert hun output en verzorgt de integratie van voltooide taken.

Uitvoeringsfase Vaardigheden

Subagent-gedreven Ontwikkeling — Zet onafhankelijke subagents in voor parallelle taakuitvoering. Als je plan drie taken bevat zonder onderlinge afhankelijkheden, voert deze vaardigheid ze alle drie gelijktijdig uit. De snelheidswinst bij complexe projecten is merkbaar — de doorlooptijd daalt aanzienlijk als onafhankelijke taken niet op elkaar hoeven te wachten.

Parallelle Agents Dispatchen — De coördinatielaag voor parallelle uitvoering. Beheert de status over gelijktijdige subagents, zorgt dat voltooide taken niet conflicteren, en regelt het samenvoegen van parallelle output.

Kwaliteitscontrole Vaardigheden

Test-gedreven Ontwikkeling — Deze vaardigheid handhaaft de TDD-methodologie: eerst falende tests schrijven, dan de minimale code schrijven om ze te laten slagen, daarna refactoren. In mijn tests was dit de grootste bijdrage aan hogere codekwaliteitscores. Zonder deze vaardigheid schrijft Claude Code eerst implementatiecode en daarna pas tests (als die er al komen). Met deze vaardigheid begint elke feature met een duidelijke "klaar"-definitie, uitgedrukt als uitvoerbare tests.

Systematisch Debuggen — Wanneer er iets misgaat, dwingt deze vaardigheid een vierfasig debugprotocol af: oorzaak identificeren, gerelateerde systemen analyseren, hypothesen genereren en de oplossing testen. Dit voorkomt het "shotgun debugging"-patroon waarbij de agent willekeurige wijzigingen aanbrengt in de hoop dat iets werkt. Ik heb gezien dat deze vaardigheid hele sessies redt die anders zouden zijn vastgelopen in eindeloze fix-cycli.

Verificatie Voor Afronding — De laatste kwaliteitscontrole. Voordat Superpowers werk als voltooid verklaart, vereist deze vaardigheid dat de test suite wordt uitgevoerd, dat alle eisen uit de verduidelijkingsfase zijn afgevinkt, en dat de code compileert en draait. Geen "ik ben klaar" meer gevolgd door directe fouten.

Code Review Vaardigheden

Code Review Aanvragen — Wordt geactiveerd zodra de implementatie klaar is. Voert een gestructureerde review uit op juistheid, stijl, performance en beveiliging voordat de code wordt gecommit.

Code Review Ontvangen — Behandelt feedback uit code reviews met wat Jesse "technische strengheid, geen performatieve instemming" noemt. De vaardigheid beoordeelt reviewcommentaar kritisch in plaats van blindelings elke suggestie over te nemen. Dit voorkomt dat reviewfeedback de code verslechtert omdat de agent niet tegen slechte suggesties ingaat.

Git Workflow Vaardigheden

Gebruik van Git Worktrees — Maakt geïsoleerde git worktrees aan voor feature-ontwikkeling. Houdt je hoofdwerkruimte schoon terwijl experimenten in aparte branches draaien. Slimme mapselectie en veiligheidscontroles voorkomen de worktree-wildgroei die handmatig git worktree-beheer vaak veroorzaakt.

Een Ontwikkelbranch Afronden — Begeleidt het afronden van ontwikkelwerk door gestructureerde opties te presenteren: mergen naar main, een PR aanmaken, of de branch opschonen. Dit voorkomt het veelvoorkomende probleem van half-afgemaakte branches die je repository vervuilen.

De Meta-Vaardigheid

Vaardigheden Schrijven — Dit is de vaardigheid waar AI-frameworkliefhebbers enthousiast van worden. Superpowers kan nieuwe Superpowers-vaardigheden schrijven volgens TDD-principes. Jij beschrijft de gewenste functionaliteit, en het framework creëert een geteste, geverifieerde vaardigheid die integreert met de rest van het systeem. Het framework breidt zichzelf uit. Ik heb dit gebruikt om project-specifieke vaardigheden te maken die de conventies van Superpowers volgen en integreren met de orkestratielaag.

De Eerlijke Beoordeling: Waar Superpowers Tekortschiet

Elke review die ik over Superpowers heb gelezen, richt zich op de successen. Dit is wat ze je niet vertellen.

Eenvoudige taken worden trager, niet sneller. Heb je een snelle utility-functie, een eenmalig script of een simpele refactor nodig, dan voegt de clarify-design-plan-overhead tijd toe zonder waarde toe te voegen. Ik ben simpele verzoeken gaan beginnen met "snelle taak, sla planning over:" en meestal respecteert de orchestrator dat. Maar standaard maakt Superpowers geen onderscheid tussen een fix van 10 regels en een feature van 10.000 regels. Op beide past het de volledige methodologie toe.

Domeinkennis verbetert niet. Superpowers maakt Claude gedisciplineerder, niet slimmer. Als het model jouw specifieke framework, jouw bedrijfsdomein of jouw eigen API’s niet begrijpt, lost Superpowers dat niet op. Het zal alleen zorgvuldiger plannen rond de kennishiaten — wat beter is dan blind coderen, maar de hiaten blijven bestaan. Je hebt nog steeds domeinspecifieke context nodig in je prompts of in CLAUDE.md.

Specificatie-naleving blijft gelijk. Als je eisen fout of onvolledig zijn, zal Superpowers trouw plannen en uitvoeren op basis van die foute of onvolledige eisen. De verhelderende vragen helpen — ze vangen sommige hiaten op — maar ze vervangen geen goed geschreven specificatie. Ik heb gezien hoe het framework een perfect geplande, perfect uitgevoerde feature bouwde die precies was wat ik vroeg, maar totaal niet wat ik eigenlijk nodig had. De methodologie is slechts zo goed als de input die het krijgt.

Tokenpieken komen voor. Ik had een sessie waarin Superpowers agressief tokens verbruikte tijdens de brainstormfase, en een uitgebreid design-companion genereerde voor een taak die dat niet verdiende. De GitHub-issues bevestigen dat dit niet uniek is voor mijn ervaring — issue #953 op de repo beschrijft een vergelijkbaar patroon. Het is zeldzaam, maar het gebeurt, en als je een krap tokenbudget hebt, moet je hiervan op de hoogte zijn.

De leercurve is echt voor teams. Ben je een solodeveloper, dan werkt Superpowers direct uit de doos. Wil je dit echter uitrollen over een team, verwacht dan vragen. De visuele companions verwarren developers die alleen terminal-workflows gewend zijn. De verhelderende vragen frustreren developers die “gewoon willen dat er gecodeerd wordt.” De TDD-handhaving irriteert developers die geen tests schrijven (en daar ook nog niet klaar voor zijn). Adoptie vereist draagvlak, niet alleen installatie.

Dit zijn geen showstoppers. Het zijn afwegingen. En als je ze van tevoren kent, kun je bepalen of de afweging voor jouw specifieke situatie logisch is.

Wanneer Superpowers Gebruiken (En Wanneer Niet)

Na een maand dagelijks gebruik is dit mijn besliskader:

Gebruik Superpowers wanneer:

• De taak meerdere bestanden, services of architecturale beslissingen omvat
• Je een feature bouwt die moet integreren met bestaande code
• De requirements vaag of complex genoeg zijn om verkeerd geïnterpreteerd te worden
• Je waarde hecht aan testdekking en code-structuur, niet alleen aan “werkt het”
• Je projectkosten inschat en voorspelbaar tokenverbruik nodig hebt
• Je werkt aan een codebase die je op de lange termijn zult onderhouden

Sla Superpowers over wanneer:

• Je snel een eenmalig script of utility nodig hebt
• De taak een simpele bugfix is met een voor de hand liggende oplossing
• Je aan het verkennen of prototypen bent en geen zin hebt in de overhead van plannen
• Het tokenbudget extreem krap is en de taak rechttoe rechtaan

De ideale toepassing — waar Superpowers de meeste waarde per gespendeerde token levert — zijn middelzware tot complexe taken in actieve, onderhouden codebases. Daar voorkomt de planning dure herwerking, vangt TDD regressies op, en versnelt de sub-agent architectuur parallelle implementatie.

Superpowers vs. De Alternatieven: Snelle Vergelijking

Superpowers is niet het enige gestructureerde framework voor Claude Code. Twee opvallende alternatieven zijn GSD (Get Stuff Done) en gstack. Zo verschillen ze op hoofdlijnen:

De keuze is niet "welke is het beste" — het is "welke past bij jouw taak." Zelf gebruik ik Superpowers standaard en schakel het soms uit voor snelle taken waarbij de lichte aanpak van GSD beter past. Het zijn complementaire tools, geen concurrenten.

Wat Dit Betekent Voor Hoe Ik Nu Werk

Na een maand heeft Superpowers mijn Claude Code-werkflow op drie specifieke manieren veranderd.

Ten eerste ben ik gestopt met Claude Code te zien als een codegenerator en ben ik het gaan behandelen als een ontwikkelingspartner. De fasen voor verduidelijking en ontwerp dwingen tot een gesprek dat er voorheen niet was. Mijn prompts zijn korter en gerichter geworden omdat ik weet dat het framework de juiste vervolgvragen zal stellen. Ik probeer niet langer elk vereiste in één enkele prompt te proppen.

Ten tweede is mijn nauwkeurigheid in projectinschattingen verbeterd. Door het voorspelbare tokengebruik kan ik AI-ondersteunde features met vertrouwen afbakenen. “Deze feature kost ongeveer X tokens om te implementeren” is nu een uitspraak die ik met een redelijke marge juist kan doen. Voor Superpowers was die schatting zo onnauwkeurig dat je er een vrachtwagen doorheen kon rijden.

Ten derde — en dit verraste me — schrijf ik betere specificaties. De verhelderende vragen leerden me welke informatie de agent daadwerkelijk nodig heeft, in tegenstelling tot wat ik uit gewoonte toevoegde. Mijn specs zijn korter, preciezer en leiden tot minder iteraties. Het framework heeft mij net zo goed getraind als de agent.

Is Superpowers het juiste gereedschap voor iedereen? Nee. Als je eenvoudige taken uitvoert, prototypet, of werkt in een domein waar planningslast niet opweegt tegen de baten, zal het je vertragen. Maar als je echte software bouwt — features die moeten werken, integreren en onderhouden worden — is de vijf-fasen-discipline geen overhead. Het is hoe professionele software wordt gebouwd. Het framework dwingt simpelweg af wat goede engineers al doen en geeft dat aan een AI die die structuur hard nodig had.

De 121.000 GitHub-sterren zijn geen hype. Het zijn 121.000 ontwikkelaars die tegen dezelfde muur aanliepen als ik — briljante AI, nul discipline — en dezelfde oplossing vonden.

Installeer het. Gebruik het bij je volgende complexe taak. En beslis dan zelf. Dat is wat ik deed, en het experiment sprak luider dan welke review dan ook.

Veelgestelde Vragen

Werkt Superpowers met alle Claude Code-modellen?

Superpowers werkt met elk model dat beschikbaar is via Claude Code, waaronder Opus 4.6 en Sonnet 4.6. De vaardigheden zijn model-agnostisch — ze passen het workflowproces aan, niet de onderliggende modelcapaciteiten. Prestatieverbeteringen schalen mee met de modelcapaciteit, dus Opus-sessies laten doorgaans grotere kwaliteitsverbeteringen zien dan Sonnet-sessies.

Hoe schakel ik Superpowers uit voor eenvoudige taken?

Begin je prompt met "quick task" of "skip planning" en de orchestrator slaat doorgaans de volledige clarify-design-plan-cyclus over. Je kunt de plugin ook tijdelijk uitschakelen met /plugin disable superpowers en weer inschakelen met /plugin enable superpowers. Voor meer gedetailleerde controle kunnen individuele vaardigheden worden in- of uitgeschakeld in de plugin-instellingen.

Veroorzaakt Superpowers conflicten met andere Claude Code-plugins of -vaardigheden?

In mijn tests gedurende vier maanden dagelijks gebruik werkt Superpowers probleemloos samen met andere plugins en aangepaste vaardigheden. De orchestrator is ontworpen om te herkennen wanneer een andere vaardigheid een verzoek moet afhandelen en doet dan een stap terug. Als je toch conflicten ervaart, controleer dan of je andere vaardigheden geen overlappende triggercondities definiëren met de kernfases van Superpowers.

Is Superpowers gratis?

Ja. Superpowers is volledig open source onder de MIT-licentie en gehost op github.com/obra/superpowers. Er zijn geen betaalde niveaus, geen premiumfuncties, geen gebruikslimieten. Het volledige framework — alle 14 vaardigheden — is gratis te installeren, te gebruiken en aan te passen.

Hoeveel bespaart Superpowers op tokenkosten?

Gebaseerd op mijn experiment met 12 sessies: gemiddeld ongeveer 9% kostenbesparing en 14% minder tokens, met de meeste besparingen bij middelgrote en complexe taken. Eenvoudige taken kunnen juist meer tokens gebruiken door de overhead van planning. De meest waardevolle metriek is consistentie — de variantie in tokengebruik daalde met een factor 2-3, waardoor projectkostenschattingen veel betrouwbaarder worden.

Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag verder.

• Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io