Superpowers laat Claude Code eerst denken, dan bouwen

Je kent het moment. Je beschrijft een feature aan Claude Code, het begint meteen te bouwen, en drie iteraties later ben je verder van huis dan toen je begon. De code compileert, maar het is niet wat je bedoelde. Superpowers, een gratis open-source plugin met meer dan 183.000 GitHub-sterren, pakt precies dat probleem aan. Het dwingt Claude Code om eerst vragen te stellen, dan een plan te schrijven en pas daarna code te produceren. Eén commando in je terminal en je coding-agent gedraagt zich als een senior developer die weet dat nadenken goedkoper is dan herschrijven.

Wat is Superpowers precies?

Superpowers is een verzameling van veertien agentic skills die Claude Code een vaste werkmethode opleggen. De plugin is gemaakt door Jesse Vincent, de developer achter onder meer Request Tracker, en staat sinds januari 2026 in de officiële Anthropic-marketplace. Inmiddels is het bijna 580.000 keer geïnstalleerd.

Het kernidee: consistentie verslaat ruwe intelligentie. Niet een slimmer model, maar een gedisciplineerder model. De plugin legt een zevenstapenworkflow op:

1. Brainstormen - socratische vragen over je requirements
2. Git-worktree - geïsoleerde branch aanmaken zodat je main-branch schoon blijft
3. Plan schrijven - taken van twee tot vijf minuten met exacte bestandspaden
4. Subagent-ontwikkeling - een verse Claude-instantie per taak
5. Test-driven development - test eerst, code daarna, geen uitzonderingen
6. Code review - tweefasige check na elke taak
7. Branch afronden - tests verifiëren en merge voorbereiden

Wacht even, veertien skills voor zeven stappen? Klopt. Naast de kernworkflow zitten er skills in voor systematisch debuggen, verificatie voor oplevering, het schrijven van nieuwe skills en het aansturen van parallelle agents. Je hoeft ze niet allemaal te gebruiken. Ze staan klaar als je ze nodig hebt.

Denk aan een architect die weigert een huis te bouwen zonder tekening. Je kunt hem dwingen om meteen met bakstenen te beginnen, maar hij weet dat de muur dan scheef komt te staan. Superpowers is die architect voor je code.

Het resultaat volgens gebruikers: werkende code bij de eerste poging, inclusief tests. Developer Evan Schwartz schreef er uitgebreid over: "Ik voel me veel zekerder dat de code doet wat ik wil, en beter over de afwegingen die zijn gemaakt." Niet sneller coderen, maar minder herschrijven.

Hoe installeer je het?

Eén commando in een actieve Claude Code-sessie:

/plugin install superpowers@claude-plugins-official

Start Claude Code opnieuw. Klaar. De plugin installeert zich globaal, dus elk project dat je opent krijgt automatisch alle skills.

Even voor de beeldvorming: je installeert hier geen extra software, geen npm-package, geen Docker-container. Superpowers bestaat uit markdown-bestanden die Claude vertellen hóé het moet werken. Die bestanden worden geladen als skills in je sessie, vergelijkbaar met instructies die je een nieuwe collega geeft op zijn eerste werkdag.

Verificatie: na herstart type je /help. Als Superpowers correct is geïnstalleerd, zie je commando's als brainstorm, write-plan en execute-plan in de lijst.

Alternatieve installatie via de Superpowers-marketplace:

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Dit geeft je toegang tot aanvullende community-skills bovenop de kernset. Beide methoden zijn gratis en open-source onder MIT-licentie.

De brainstorm-fase stap voor stap

De brainstorm-skill laat Claude eerst vragen stellen over je requirements voordat er een regel code wordt geschreven. Dat is het hart van Superpowers en de reden waarom de plugin zo goed werkt voor middelgrote en grote projecten. In plaats van meteen code te schrijven, start Claude een gestructureerd gesprek met jou.

Je typt bijvoorbeeld:

Ik wil een dashboard bouwen dat onze klanttevredenheidsscores toont, met filters per regio en periode.

Claude springt niet naar React-componenten of database-schema's. Het stelt één vraag tegelijk:

• "Welk framework gebruik je al in dit project?"
• "Moet het dashboard real-time data tonen of is dagelijkse verversing voldoende?"
• "Wie zijn de gebruikers: het managementteam, de klantenservice, of beide?"

Elk antwoord scherpt het ontwerp aan. Eén vraag per bericht, geen waslijst. Na de vragen presenteert Claude twee tot drie mogelijke aanpakken met de afwegingen erbij. Pas als jij akkoord geeft, gaat het verder.

Het ontwerp wordt opgeslagen als een markdown-bestand in docs/superpowers/specs/. Dat is geen formaliteit. Dat bestand is het contract waar de rest van het project op leunt. Als Claude later afdwaalt, wijs je terug naar de spec. Een collega van Schwartz noemde dit "veel krachtiger dan de normale Claude Code-ervaring", juist omdat het plan een bewerkbaar bestand is dat jij zelf kunt bijsturen.

Een developer testte Superpowers op een project genaamd Ding, een stateless alerting daemon. De brainstorm-fase produceerde een specificatie van 424 regels die drie architectuurbeslissingen vastlegde voordat er ook maar één regel code werd geschreven. Het resulterende plan besloeg 17 bestanden verdeeld over 26 taken. Zonder de brainstormfase had Claude waarschijnlijk de verkeerde cooldown-logica geïmplementeerd, en was de developer drie uur verder geweest voordat hij dat doorhad.

Overigens, sinds versie 5.0 zit er ook een visuele companion bij. Werk je aan iets met een UI-component? Dan kan Claude een lokale dev-server starten met mockups en diagrammen die je in de browser bekijkt en bespreekt. Geen installatie nodig, draait op WebSockets zonder externe dependencies.

En tot slot een detail dat te mooi is om niet te noemen. Jesse Vincent past bewust overtuigingsprincipes van Robert Cialdini toe in de skill-instructies. Superpowers simuleert scenario's waarin een gebruiker tijdsdruk voelt of al code heeft geschreven, om te testen of Claude alsnog het proces volgt. Gedragspsychologie, ingezet op een AI-agent. Het werkt.

Waarom werken taken van vijf minuten beter dan zes uur rework?

Kleine taken van vijf minuten voorkomen contextdrift en leveren werkende code bij de eerste poging, waar grote sessies gemiddeld vier tot vijf iteratiecycli nodig hebben. De meeste developers kennen dit patroon: je beschrijft wat je wilt, Claude schrijft honderd regels code, je test het, het werkt half, je corrigeert, Claude herschrijft alles. Drie rondes later heb je iets dat functioneert maar waarvan je niet meer zeker weet of het klopt.

Superpowers breekt dat patroon door elk project op te knippen in taken van twee tot vijf minuten. Elke taak bevat:

• Het exacte bestandspad dat verandert
• De complete failende test, geen pseudocode maar echte code
• De minimale implementatie die de test laat slagen
• Het git-commit-bericht

De maatstaf: iemand die het project niet kent moet het plan correct kunnen uitvoeren zonder extra uitleg.

Hier wordt het interessant. Elke taak wordt uitgevoerd door een verse subagent. Niet dezelfde Claude-sessie die al duizend tokens context heeft opgebouwd, maar een schone instantie die alleen het plan en de relevante bestanden ziet. Dat voorkomt contextdrift, het verschijnsel waarbij Claude na een uur in dezelfde sessie langzaam afwijkt van het oorspronkelijke doel. Eerder schreef ik over hoe je met meerdere agents tegelijk aan één project werkt, en het subagent-model van Superpowers formaliseert precies dat principe.

De resultaten die gebruikers rapporteren: vóór Superpowers vier tot vijf iteratiecycli nodig voor werkende code. Erna werkende code bij de eerste poging, mét tests. Een developer die het framework drie maanden dagelijks testte documenteerde: vijf minuten brainstormen, twee minuten plan reviewen, en dan de uitvoering. De initiële overhead van tien tot twintig minuten bespaart uren aan rework.

Test-driven development als afdwingbare regel

Superpowers is onverbiddelijk over testen. Schrijft Claude code vóór de test? Dan moet het die code verwijderen en opnieuw beginnen. Test eerst, implementatie daarna. Punt.

De red-green-refactor-cyclus:

1. Red: schrijf een test die faalt
2. Green: schrijf precies genoeg code om de test te laten slagen
3. Refactor: verbeter de code zonder de test te breken

Na elke taak volgt een tweefasige review. Eerst controleert een automatische check of de code aan de specificatie voldoet. Dan kijkt een verse subagent naar kwaliteit, security en testdekking. Rapporteert die subagent een probleem? Dan gaat de taak terug. Falen drie opeenvolgende taken? Dan stopt het hele proces. Geen eindeloos doormodderen, maar een bewuste pauze om te evalueren wat er mis gaat.

Voor jou als developer of bureau-eigenaar die Claude Code inzet bij klantprojecten is dit het verschil tussen "de AI heeft iets gemaakt" en "we leveren software op met testdekking." Je kunt de code reviewen, de tests draaien, en met vertrouwen opleveren. Bij een gemiddeld Nederlands webbureau dat twintig tot dertig uur per project kwijt is aan development, kan dat verschil oplopen tot vijf tot tien uur per project aan bespaarde iteratietijd.

Vijf tips voor de beste resultaten

1. Wees specifiek in je brainstorm-prompt. "Bouw een dashboard" is vaag. "Bouw een klanttevredenheidsdashboard in Next.js met Supabase-backend, gefilterd per regio en kwartaal, voor het managementteam" geeft Claude genoeg houvast om gerichte vragen te stellen in plaats van brede.

2. Lees en bewerk het plan voordat je het uitvoert. Het plan is een markdown-bestand in je repository. Open het, lees het door, corrigeer aannames die niet kloppen. Claude weet bijvoorbeeld niet dat jouw API al op OAuth draait in plaats van API-keys. Vijf minuten planreview bespaart een uur debugging.

3. Start een nieuwe sessie voor de uitvoering. Na brainstormen en plannen heeft Claude veel context opgebouwd. Start een verse Claude Code-sessie voordat je het plan uitvoert. De schone context voorkomt dat oude gesprekslijnen de uitvoering vervuilen.

4. Maak project-specifieke skills. Superpowers is uitbreidbaar. Heb je een huisstijl voor je componenten? Een vaste manier van foutafhandeling? Schrijf het als een skill-bestand in .claude/skills/ en Claude volgt het bij elk project. Skills zijn gewone markdown-bestanden, geen code. Claude Dreaming kan zelfs automatisch lessen uit eerdere sessies omzetten naar nieuwe skills.

5. Gebruik meerdere Claude-instanties voor review. Laat een tweede Claude Code-sessie de output van de eerste reviewen. Twee instanties vangen aannames die één sessie normaliseert. Een developer die dit consequent doet rapporteerde dat edge cases als new Date()-aanroepen die prerendering breken wél werden gevonden, terwijl een enkele sessie ze over het hoofd zag.

Wanneer past Superpowers niet?

Niet elk project heeft een gestructureerde workflow nodig. Superpowers voegt tien tot twintig minuten overhead toe aan het begin, en dat is het niet waard als je:

• Een snelle bugfix doet van drie regels
• Een proof-of-concept maakt dat je morgen weggooit
• Een typo fixt in een config-bestand
• Onder extreme tijdsdruk werkt waarbij de overhead niet te rechtvaardigen is

Ook environment-debugging valt buiten de workflow. Als je macOS-specifieke shellproblemen hebt of Docker-containers weigeren te starten, moet je buiten het gestructureerde proces om debuggen. Superpowers weet niet hoe jouw specifieke serverconfiguratie eruitziet.

De vuistregel: duurt je project langer dan een uur en wil je het goed doen? Gebruik Superpowers. Voor alles wat korter is, is de directe Claude Code-ervaring prima.

Wat kun je er komende week mee?

Installeer het. Eén commando, twee minuten. Begin met een feature die je al een tijdje wilt bouwen maar steeds uitstelt omdat het "te complex" is voor een AI-sessie.

Start met /brainstorm en beschrijf wat je wilt. Laat Claude de vragen stellen. Keur het plan goed of pas het aan. Zet het aan het werk. Je zult merken dat de eerste sessie al anders voelt: minder heen-en-weer, meer vertrouwen in het resultaat.

De plugin is gratis en open-source onder MIT-licentie. Je betaalt er niks extra voor bovenop je bestaande Claude-abonnement. Bij een Claude Pro-abonnement van twintig euro per maand heb je meer dan genoeg ruimte voor meerdere Superpowers-sessies per dag. En als je al op Claude Max van 180 euro per maand zit, is de overhead van de brainstorm- en planfase verwaarloosbaar ten opzichte van de tokens die je bespaart door minder te herschrijven.

183.000 GitHub-sterren, bijna 580.000 installaties, en een plek in de officiële Anthropic-marketplace. Dit is geen experiment meer. Het is hoe een groeiende groep developers hun AI-agent aanstuurt. En jij kunt het in twee minuten installeren.

Schrijf je in voor onze dagelijkse AI-nieuwsbrief als je dit soort tools en tips niet wilt missen.

Veelgestelde vragen

Wat is de Superpowers-plugin voor Claude Code?

Superpowers is een gratis, open-source plugin die Claude Code een gestructureerde werkwijze oplegt. Het dwingt de AI-agent om eerst te brainstormen, dan een plan te schrijven en pas daarna code te produceren. De plugin bevat veertien skills voor onder meer TDD, code review en subagent-ontwikkeling.

Hoe installeer je Superpowers in Claude Code?

Open een Claude Code-sessie en type /plugin install superpowers@claude-plugins-official. Start Claude Code opnieuw op en de plugin is actief. De installatie is globaal, dus elk project krijgt automatisch de skills.

Is Superpowers gratis?

Ja, Superpowers is volledig gratis en open-source onder MIT-licentie. Je betaalt er niks extra voor bovenop je bestaande Claude-abonnement. De plugin is gemaakt door Jesse Vincent en wordt onderhouden door de community.

Hoe werkt de brainstorm-functie van Superpowers?

De brainstorm-functie stelt vragen over je requirements, constraints en doelen. Na de vragen presenteert Claude twee tot drie mogelijke aanpakken met afwegingen. Het goedgekeurde ontwerp wordt opgeslagen als markdown-bestand dat als contract dient voor de rest van het project.

Wanneer moet je Superpowers niet gebruiken?

Superpowers voegt tien tot twintig minuten overhead toe en is niet geschikt voor snelle bugfixes, wegwerp-prototypes of werk onder extreme tijdsdruk. De vuistregel: gebruik het als je project langer dan een uur duurt en je het goed wilt doen.