Claude Code's /powerup Command Leert Je Alles Binnen de Terminal
Ik was halverwege het schrijven van een CLAUDE.md-bestand voor een nieuw project toen ik claude --version uitvoerde en zag dat het nummer was opgehoogd. Versie 2.1.90. Vers.
Normaal gesproken zou ik doorwerken. Versie-updates gebeuren constant bij Claude Code — Anthropic levert updates in een tempo dat de meeste SaaS-bedrijven doet lijken alsof ze nog met waterfall werken. Maar iets in de changelog trok mijn aandacht: /powerup. Een nieuw slash-commando. Geen gedetailleerde beschrijving. Alleen een naam die klonk alsof hij thuishoorde in een videogame.
Dus typte ik het. En wat er daarna gebeurde, zorgde ervoor dat ik mijn project sloot, de CLAUDE.md opzij legde, en de volgende vijfenveertig minuten iets deed wat ik al jaren niet meer in een terminal had gedaan.
Ik was aan het leren. Niet Googlen. Niet een YouTube-tutorial bekijken op een tweede monitor. Niet documentatie doorspitten. Leren — interactief, stap voor stap, precies waar ik code schrijf.
Dat is het bijzondere aan /powerup dat moeilijk over te brengen is in een changelog-opsommingsteken. Het voegt geen feature toe aan Claude Code. Het voegt een leraar toe.
Wat Claude Code 2.1.90 Daadwerkelijk Brengt
Voordat ik specifiek op /powerup inga, is hier wat je moet weten over de release. Claude Code heeft in heel 2026 een meedogenloos update-tempo gehad. Versie 2.1.89 landde op 1 april met uitgestelde toestemmingshooks, flikkervrije alt-screen rendering en verbeteringen aan benoemde subagenten. Versie 2.1.88 daarvoor verscherpte de delegatierichtlijnen voor agents en loste caching van gestructureerde output-schema's op. Dit zijn betekenisvolle verbeteringen onder de motorkap — het soort dat je dagelijkse workflow soepeler maakt zonder dat je per se merkt waarom.
Maar 2.1.90 is anders. Niet vanwege infrastructuurverbeteringen, maar omdat Anthropic iets deed wat ik nog niet heb gezien bij welk CLI-tool dan ook: ze bouwden een interactief onderwijssysteem rechtstreeks in het product.
Het /powerup-commando lanceert gestructureerde, praktische lessen die je leren hoe je Claude Code gebruikt — terwijl je in Claude Code zit. Zie het als onboarding die echt werkt, aangeboden op het moment dat je het meest geneigd bent het te onthouden: wanneer je al in de tool zit, al in context bent, al aan code denkt.
Ik gebruik Claude Code nu dagelijks al meer dan zes maanden. Ik heb een complete handleiding voor beginners geschreven, vijftig tips die ik graag op dag één had geweten verzameld, en complete agentsystemen in deze terminal gebouwd. En /powerup leerde me toch nog dingen die ik niet wist.
Dat is ofwel een bewijs van hoe diep Claude Code is geworden, of een aanklacht tegen hoeveel ik miste. Waarschijnlijk allebei.
Hoe /powerup Werkt — Stap voor Stap
Hier is precies wat er gebeurt als je /powerup typt en op enter drukt.
Je krijgt een menu. Geen muur van tekst. Geen link naar documentatie. Een overzichtelijke, interactieve selectie van lesmodules, elk gericht op een specifieke Claude Code-mogelijkheid. De lessen zijn geen abstracte uitleg — het zijn begeleide oefeningen. Claude leidt je door een concept, vraagt je het te proberen, observeert wat je doet en reageert op basis van je acties.
De eerste les die ik koos was gericht op contextbeheer — hoe Claude Code je project leest, wat er in het contextvenster terechtkomt, en hoe je bepaalt wat de AI ziet. Ik heb hier uitgebreid over geschreven. Ik dacht dat ik het volledig begreep. Maar de interactieve doorloop onthulde een nuance over hoe .claudeignore-bestanden interacteren met het /compact-commando die ik nooit eerder had verbonden. Wanneer je een gesprek compact maakt, worden de ignore-regels opnieuw geëvalueerd. Bestanden die je had uitgesloten kunnen weer in de context verschijnen als je ignore-patronen pad-relatief zijn en je tijdens de sessie van map bent veranderd.
Dat is het soort detail dat je alleen zou ontdekken door pijnlijk debuggen of doordat iemand je er doorheen leidt met je daadwerkelijke omgeving voor je neus. /powerup doet dat laatste.
De Lesstructuur
Elke les volgt een consistent patroon dat ik oprecht goed ontworpen vond:
1. Conceptintroductie — Een korte, informele uitleg van wat je gaat leren. Geen academisch taalgebruik. Het leest alsof een senior engineer je iets uitlegt via een gedeeld scherm.
2. Begeleide oefening — Claude vraagt je een specifieke actie uit te voeren. Typ dit commando. Maak dit bestand aan. Voer deze prompt uit. De oefening gebruikt je echte terminal en je echte projectcontext — geen sandbox of nep-omgeving.
3. Observatie en feedback — Nadat je de actie hebt voltooid, analyseert Claude wat er is gebeurd en legt het resultaat uit. Als er iets onverwachts gebeurt (en dat gebeurt vaak, omdat echte omgevingen rommelig zijn), bespreekt het de afwijking direct in plaats van het te negeren.
4. Progressie — Elke les bouwt voort op de vorige. Je leert niet alleen losse trucs. Je bouwt een mentaal model op van hoe de onderdelen samenhangen.
Ik doorliep vier lessen in die eerste sessie. Contextbeheer, toestemmingsmodi, het /compact-commando en een introductie tot hooks. Elk duurde ongeveer tien minuten. En hier is het deel dat me verraste — ze voelden effectiever dan welke tutorial ik ook heb gelezen of bekeken over het onderwerp, inclusief de tutorials die ik zelf heb geschreven.
Het verschil is directe feedback in je eigen omgeving. Wanneer een YouTube-tutorial je een commando toont, kijk je naar iemand anders' terminal. Wanneer /powerup je door een commando leidt, voer je het zelf uit, in je eigen project, met je eigen bestandsstructuur. Het leren beklijft omdat de context echt is.
Waarom Dit Belangrijker Is Dan Weer Een Nieuwe Feature
Ik wil even afstand nemen van de details, want de implicaties van /powerup reiken verder dan "Anthropic heeft een tutorial toegevoegd."
Hier is het probleem waarmee elke ontwikkelaarstool wordt geconfronteerd: de kloof tussen installatie en bekwaamheid. Je installeert een tool. Je gebruikt misschien 20% van de mogelijkheden. Je ontwikkelt gewoonten op basis van die 20% en heroverweegt nooit de andere 80%, zelfs wanneer die mogelijkheden je uren per week zouden besparen.
Ik ken dit patroon heel goed want ik heb het zelf meegemaakt met Claude Code. In mijn eerste drie maanden gebruikte ik /compact niet. Ik begreep hooks niet. Ik wist niet dat je midden in een sessie van model kon wisselen met /model. Ik verbrandde API-credits alsof ze gratis waren omdat ik geen mentaal model had voor contextvenster-beheer. Toen ik uiteindelijk mijn 50 Claude Code tips-gids schreef, waren de helft van de tips dingen die ik gênant laat had ontdekt.
De traditionele oplossing voor dit probleem is documentatie. Schrijf het op, publiceer het, hoop dat mensen het lezen. De iets betere oplossing is tutorials — video- of geschreven doorlopen die de tool in actie laten zien. Maar beide lijden aan dezelfde fundamentele ontkoppeling: ze vinden buiten de tool plaats. Je leest de documentatie, tabelt terug naar je terminal, probeert te herinneren wat je net las, faalt, tabelt terug naar de documentatie. De leercyclus heeft te veel wrijving.
/powerup elimineert die wrijving volledig. De les is de tool. De tool is de les. Er is geen contextwissel. Er is geen "laat me even opzoeken waar ik was in de documentatie." Er is geen video pauzeren en dertig seconden terugspoelen.
Deze aanpak heeft een naam in onderwijsonderzoek: gesitueerd leren. Je leert het beste wanneer het leren plaatsvindt in dezelfde omgeving waar je de kennis zult toepassen. Medische studenten leren in ziekenhuizen, niet alleen in collegezalen. Piloten leren in simulatoren, niet alleen in klaslokalen. En nu leren Claude Code-gebruikers binnen Claude Code.
Ik besef dat dat dramatisch klinkt voor een CLI-tool. Maar denk aan de schaal. Claude Code is een van de meest gebruikte AI-ontwikkeltools ter wereld geworden. Anthropic's eigen cijfers suggereren dat 90-95% van Claude Code nu door Claude Code wordt geschreven. De populatie ontwikkelaars die deze tool dagelijks gebruikt is enorm en groeiend. Zelfs een kleine verbetering in hoe snel die ontwikkelaars bekwaam worden heeft een buitenproportioneel effect op de totale productiviteit.
Wat de Lessen Behandelen — En Wat Ontbreekt
Op basis van mijn eerste volledige sessie met /powerup, hier is wat ik beschikbaar vond.
De lessen bestrijken verschillende kernmogelijkheden van Claude Code. Context- en geheugenbeheer krijgt solide dekking — hoe het contextvenster werkt, wat het vult, hoe je /compact en .claudeignore effectief gebruikt, en hoe CLAUDE.md-bestanden het gedrag van de AI vormgeven. Ik behandelde veel van deze concepten in mijn masterclass Claude Code, maar het interactieve formaat laat de concepten anders landen.
Toestemmingsmodi zijn goed vertegenwoordigd. De les leidt je door elke modus — Ask, Auto Accept, Planning en volledig autonoom — met praktische scenario's voor wanneer elk zinvol is. Het weerspiegelt wat ik beschreef in mijn desktop-app review, maar met het voordeel dat je in realtime van modus kunt wisselen en de gedragsverschillen met eigen ogen kunt waarnemen.
Slash-commando's krijgen een eigen les die verder gaat dan alleen opsommen. Je leert wanneer je /clear versus /compact moet gebruiken (een onderscheid dat bijna iedereen in het begin verwart), hoe het wisselen via /model kwaliteit en kosten beïnvloedt, en hoe /cost je helpt je uitgaven tijdens een sessie bij te houden.
Hooks — een van de krachtigste en minst begrepen functies van Claude Code — krijgen een introductie die ik oprecht nuttig vond. De les leidt je door het aanmaken van een eenvoudige PreToolUse-hook, iets waar ik ervaren ontwikkelaars mee heb zien worstelen omdat de documentatie, hoewel accuraat, je hand niet vasthoudt bij de eerste implementatie.
Wat ontbreekt? Skills. Op het moment van deze versie vond ik geen /powerup-les die het aanmaken van skills behandelt — het schrijven van SKILL.md-bestanden, het skill-aanroeppatroon, of hoe skills verschillen van slash-commando's. Gezien het feit dat skills een van de functies zijn die basis Claude Code-gebruik onderscheiden van poweruser-workflows, voelt dit als een lacune. Ik zag ook geen dekking van worktrees, het /loop-commando, of multi-agent orchestratie. Deze komen misschien in toekomstige updates — het lesframework ondersteunt duidelijk uitbreiding — maar ze zijn er nu nog niet.
Het andere dat me opviel: de lessen zijn momenteel geoptimaliseerd voor terminaal-gebaseerd Claude Code. Er is geen specifieke begeleiding voor de desktop-app-ervaring of voor VSCode-integratie. En dat brengt me bij iets waar ik over nadenk sinds ik /powerup voor het eerst uitvoerde.
De VSCode- en Desktop-App-Vraag
Hier is wat me echt nieuwsgierig maakt: hoe zal /powerup vertalen naar niet-terminal-omgevingen?
De Claude Code desktop-app — die ik uitgebreid heb besproken — heeft zijn eigen interactieparadigma. Multi-paneel lay-outs. Visuele bestandsbomen. Live previews. Het toestemmingssysteem werkt conceptueel hetzelfde, maar het oppervlak is anders. Een les ontworpen voor de terminal past misschien niet naadloos bij de desktop-ervaring.
En dan is er VSCode. De Claude Code-extensie voor VSCode wint aan populariteit, en de interface verschilt fundamenteel van zowel de terminal-CLI als de zelfstandige desktop-app. Zijpanelen. Inline-suggesties. Chatvensters ingebed in de editor-omgeving. Een interactieve les die zegt "typ dit in je terminal" werkt niet als er geen terminal is in de traditionele zin.
Mijn inschatting — en dit is speculatie op basis van hoe Anthropic eerder cross-platform features heeft aangepakt — is dat /powerup zich zal aanpassen aan zijn omgeving. De lesinhoud blijft hetzelfde, maar de instructies passen zich aan op basis van of je in CLI-modus, desktop-modus of VSCode-modus zit. Anthropic is consistent goed geweest in het laten werken van features op al hun platformen, zelfs wanneer de implementatiedetails aanzienlijk verschillen.
Maar ik weet het nog niet zeker. De desktop-app- en VSCode-versies van 2.1.90 zijn op het moment van schrijven nog niet op mijn machines verschenen. Wanneer dat wel zo is, update ik dit bericht met mijn bevindingen. Voorlopig is de terminal-ervaring waar ik over kan spreken — en die is solide.
Wat Ik Leerde Dat Ik Niet Verwachtte Te Leren
Zes maanden dagelijks gebruik. Honderden uren in deze tool. Meerdere gepubliceerde artikelen over Claude Code-workflows. En /powerup bracht toch dingen naar boven die ik had gemist.
De interactie tussen .claudeignore en /compact die ik eerder noemde was er één. Hier is nog een: tijdens de les over toestemmingen leerde ik dat de nieuwe "defer"-beslissing van de PreToolUse-hook — die een dag eerder in versie 2.1.89 was uitgebracht — kan worden gebruikt om goedkeuringsworkflows te creëren voor headless-sessies. Een CI-pipeline die Claude Code draait kan pauzeren bij een specifieke tool-aanroep, wachten op menselijke beoordeling, en hervatten. Ik wist dat de defer-optie bestond door het lezen van de changelog. Wat ik niet begreep was de praktische workflow: hoe je het daadwerkelijk opzet, hoe het hervattingscommando eruitziet, en wat er met de sessiestatus gebeurt terwijl deze gepauzeerd is.
De /powerup-les over hooks leidde me door het bouwen van precies deze workflow. In tien minuten had ik een werkende PreToolUse-hook die bestandsschrijfbewerkingen uitstelde in headless-modus en hervatte via claude -p --resume. Tien minuten. Van concept tot werkende implementatie. Zonder de terminal te verlaten, zonder een browser te openen, zonder een enkele documentatiepagina te lezen.
Dat is de pedagogische kracht van leren-door-doen in context. De les legde het concept niet uit en hoopte dat ik de implementatie zou uitzoeken. Het leidde me door de implementatie en liet het concept ontstaan uit de ervaring.
Nog iets dat ik niet verwachtte: de lessen zijn conversationeel. Ze stellen je vragen. "Wat denk je dat er zal gebeuren als je dit commando uitvoert?" En ze wachten op je antwoord voordat ze verdergaan. Dit is geen scrollende muur van instructies. Het is een dialoog. Claude Code voert oprecht een leergesprek met je.
Ik heb genoeg tijd doorgebracht rond onderwijstechnologie om te weten dat dit moeilijk goed te krijgen is. De meeste "interactieve" leertools zijn gewoon documentatie met knoppen. Het feit dat Claude — een AI — je leert hoe je Claude kunt gebruiken op een manier die aanvoelt als samenwerken met een geduldige senior engineer is... nou, het is een recursief soort indrukwekkend.
De Concurrentie: Wie Doet Dit Nog Meer?
Kort antwoord: niemand. Niet op deze manier.
Cursor heeft onboarding-flows. GitHub Copilot heeft documentatie. Windsurf heeft tutorials. Maar geen van hen bedt interactief, progressief onderwijs rechtstreeks in de tool zelf in, draaiend op je echte codebase, aangepast aan je echte omgeving.
De dichtstbijzijnde vergelijking die ik kan bedenken is Vim's ingebouwde vimtutor — een opdrachtregeltutorial die je Vim leert door je Vim te laten gebruiken. Ontwikkelaars prijzen vimtutor al tientallen jaren juist omdat het de kloof tussen leren en doen elimineert. /powerup is dat concept, geëvolueerd. In plaats van een statisch tekstbestand heb je een AI-tutor die kan reageren op wat je doet, zich kan aanpassen aan je fouten, en de les kan bijstellen op basis van je omgeving.
De reden dat dit competitief uitmaakt is niet alleen gebruikersonboarding. Het is retentie. De belangrijkste reden waarom ontwikkelaars krachtige tools verlaten is frustratie met de leercurve. Ze lopen tegen een muur, Googlen het antwoord, vinden het niet snel genoeg, en vallen terug op hun oude workflow. /powerup onderschept deze faalwijze bij de bron. Je hoeft de tool niet te verlaten om de tool te leren.
Voor Anthropic is dit slimme productstrategie. Elke ontwikkelaar die door /powerup gaat wordt een effectievere Claude Code-gebruiker, wat betekent dat ze meer waarde halen uit hun abonnement, wat betekent dat ze minder geneigd zijn op te zeggen. Educatie als retentie. Het is geen nieuw idee, maar de uitvoering hier is beter dan alles wat ik heb gezien in de ontwikkelaarstoolsruimte.
Hoe Ik /powerup Ga Gebruiken
Hier is mijn plan, en ik denk dat het een redelijk sjabloon is voor iedereen die dit leest.
Voor nieuwe projecten: Ik ga /powerup uitvoeren vóór /init bij mijn volgende frisse project. De les over contextbeheer is het waard om te herhalen wanneer je CLAUDE.md nog blanco is, want het dwingt je om bewust na te denken over wat je wilt dat Claude wel en niet ziet. Mijn gewoonte was om /init te doen en dan meteen te gaan prompten. Vijftien minuten /powerup vooraf nemen bespaart waarschijnlijk uren verwarring halverwege het project.
Voor het inwerken van teamleden: Ik werk samen met freelancers en medewerkers die Claude Code op wisselende vaardigheidsniveaus gebruiken. Voorheen stuurde ik ze mijn beginnersgids en volgde een week later op. Nu ga ik zeggen: installeer Claude Code, voer /powerup uit, doorloop de eerste vier lessen, dan praten we. Het interactieve formaat zal beter aankomen dan een artikel van 5.000 woorden, hoe pijnlijk dat ook is om toe te geven.
Om bij te blijven: Anthropic levert features sneller dan ik erover kan schrijven. Ik miste de defer-hook een volle dag ondanks het lezen van de 2.1.89-changelog. Als /powerup zijn lesbibliotheek bijwerkt bij nieuwe releases — en dat verwacht ik — wordt het een ingebouwd "wat is er nieuw en hoe gebruik ik het"-kanaal. Dat is waardevoller voor mij dan welke changelog dan ook, want het is uitvoerbaar.
Voor contentcreatie: Kijk, ik schrijf constant over Claude Code. Elke /powerup-les is een potentieel artikelonderwerp, een workflow die ik publiekelijk kan testen, een tip die ik kan delen met mijn publiek. De les over hooks alleen al gaf me drie ideeën voor artikelen die ik nog niet heb geschreven. Deze tool gaat mijn contentpijplijn net zo voeden als mijn ontwikkelworkflow.
De Eerlijke Beoordeling
Ik ben de afgelopen paar honderd woorden enthousiast geweest over /powerup, dus laat me dat balanceren met de beperkingen die ik zie.
De lesbibliotheek is onvolledig. Grote features zoals skills, worktrees, /loop, agent-orchestratie en multi-bestand refactoring-patronen hebben nog geen lessen. Voor een poweruser dekt de huidige bibliotheek misschien 40% van wat Claude Code kan. Dat is prima voor een eerste release, maar het betekent dat de feature zijn volle potentieel niet bereikt totdat de lescatalogus de featureset heeft ingehaald.
De lessen gaan ervan uit dat je in een terminal zit. Als je voornamelijk de desktop-app of VSCode gebruikt, moet je sommige instructies mentaal vertalen. Geen dealbreaker, maar een wrijvingspunt.
Er is geen voortgangsbijhouding die ik heb kunnen vinden. Als ik vandaag vier lessen afmaak en volgende week terugkom, begin ik bij hetzelfde menu. Lesstatus blijft niet behouden over sessies heen. Voor een tool die draait om progressief leren voelt dit als een gemis dat waarschijnlijk wordt aangepakt.
En de lessen, hoe goed ze ook zijn, kunnen diep begrip niet vervangen. Ze zijn een startpunt, geen eindbestemming. De /powerup-les over hooks leerde me hoe ik een basale PreToolUse-hook maak — maar behandelde geen hook-compositie, foutafhandelingsstrategieën, of de architectuurpatronen die ontstaan wanneer je hooks combineert met skills en aangepaste agents. Die diepgang vereist nog steeds documentatie, experimenteren, en het soort vallen-en-opstaan dat geen enkele tutorial volledig kan vervangen.
Maar hier is mijn eerlijke oordeel: ondanks deze beperkingen is /powerup de meest doordachte onboarding-ervaring die ik dit jaar ben tegengekomen bij welke ontwikkelaarstool dan ook. Het ontmoet ontwikkelaars waar ze zijn — in de terminal, al aan het werk — en leert ze zonder ze van hun werk weg te trekken. Dat is een ontwerpfilosofie waar ik achter kan staan.
Wat Ik Hierna in de Gaten Houd
Ik ga deze release verder verkennen. Er zijn een paar dingen die ik de komende dagen specifiek wil testen.
Ten eerste, hoe de lesbibliotheek uitbreidt. Als Anthropic lessen toevoegt parallel aan nieuwe features — lever de feature, lever de /powerup-les in dezelfde release — zou dat een betekenisvolle verandering zijn in hoe ontwikkelaars nieuwe mogelijkheden omarmen. Geen changelogs meer lezen en je afvragen wat een feature in de praktijk eigenlijk doet.
Ten tweede, het cross-platform verhaal. Op het moment dat /powerup native werkt in de Claude Code desktop-app en VSCode-extensie, wordt het een universele onboarding-tool over Anthropic's gehele ontwikkelaarsoppervlak. Dat is een grotere zaak dan het klinkt, want elk platform trekt een iets ander ontwikkelaarsprofiel aan. Terminal-gebruikers zijn meestal powerusers. Desktop-app-gebruikers willen meestal visuele feedback. VSCode-gebruikers hechten meestal waarde aan strakke editor-integratie. Als de lessen zich aanpassen aan elke context, is dat oprecht indrukwekkend engineerwerk.
Ten derde, community-bijgedragen lessen. Claude Code ondersteunt al door gebruikers gemaakte skills via SKILL.md-bestanden. Het framework voor aangepaste /powerup-lessen — als Anthropic het openstelt — zou een ecosysteem van door de community onderwezen mogelijkheden kunnen creëren. Stel je voor dat een Rails-ontwikkelaar een /powerup-les maakt voor Rails-specifieke Claude Code-workflows, of een beveiligingsengineer lessen bouwt rond veilige codeerpatronen met AI-assistentie. Het platformpotentieel hier is significant.
En ten vierde, de data. Anthropic zal vermoedelijk kunnen zien welke lessen worden afgemaakt, welke ontwikkelaars halverwege verlaten, en welke features nog steeds verwarrend zijn na de les. Die gebruiksdata kunnen productbeslissingen sturen op een manier die changelog-commentaren en Twitter-feedback niet kunnen. Het is een feedbackloop ingebouwd in het onderwijssysteem zelf.
Het Grotere Plaatje
Hier is waar ik steeds op terugkom. De markt voor ontwikkelaarstools in 2026 is drukker dan ooit. Elke week brengt een nieuwe AI-codeerassistent, een nieuwe IDE-extensie, een nieuwe "maak je productiviteit 10x" belofte. De meeste concurreren op features. Meer modellen. Snellere generatie. Betere autocomplete.
Anthropic concurreert met /powerup op iets anders: begrip. Niet alleen ontwikkelaars een krachtigere tool geven, maar ervoor zorgen dat ze ook daadwerkelijk weten hoe ze de kracht die ze al hebben moeten gebruiken.
Dat is een inzet op educatie boven feature-ophoping. En op basis van wat ik die vijfenveertig minuten vanmorgen heb ervaren — lessen volgen in mijn terminal, dingen leren die ik niet wist over een tool die ik elke dag gebruik — is het een inzet die wel eens vruchten zou kunnen afwerpen.
Het versienummer is 2.1.90. Het /powerup-commando is live. Als je Claude Code draait, update en probeer het voordat je vandaag iets anders doet.
Je zou weleens verrast kunnen zijn door wat je hebt gemist.
Veelgestelde Vragen
Wat doet /powerup in Claude Code?
Het /powerup-commando lanceert interactieve, begeleide lessen direct in de terminal-interface van Claude Code. Elke les leert een specifieke Claude Code-mogelijkheid — contextbeheer, toestemmingen, slash-commando's, hooks — door middel van praktische oefeningen in je echte projectomgeving. Typ /powerup in een willekeurige Claude Code-sessie om het lesmenu te openen.
Hoe update ik naar Claude Code 2.1.90?
Voer npm update -g @anthropic-ai/claude-code uit in je terminal en verifieer met claude --version. Als je een beheerde bedrijfsinstallatie hebt, kan je beheerder het updateschema bepalen. De update bevat /powerup samen met andere verbeteringen uit recente releases.
Werkt /powerup in VSCode en Claude Code Desktop?
Op het moment van de initiële 2.1.90-release is /powerup geoptimaliseerd voor de terminal-CLI-ervaring. Hoe het zich aanpast aan de Claude Code desktop-app en VSCode-extensie moet nog blijken — controleer op updates in volgende releases. De lesinhoud zal naar verwachting overzetten naar alle platformen. Voor een volledig overzicht van de desktop-app, zie mijn Claude Code Desktop review.
Is /powerup nuttig voor ervaren Claude Code-gebruikers?
Ja. Zelfs na zes maanden dagelijks gebruik onthulden de /powerup-lessen details die ik had gemist — met name rond hoe .claudeignore interacteert met /compact en hoe de nieuwe defer-hookbeslissing in de praktijk werkt. De lessen zijn progressief, dus ervaren gebruikers kunnen de basis overslaan en zich richten op geavanceerde mogelijkheden.
Welke lessen zijn momenteel beschikbaar in /powerup?
De initiële lesbibliotheek behandelt context- en geheugenbeheer, toestemmingsmodi, kern-slashcommando's (inclusief /compact, /model en /cost), en een introductie tot hooks. Skills, worktrees, /loop en multi-agent-orchestratie-lessen zijn nog niet opgenomen maar worden verwacht in toekomstige updates.
Laten We Samenwerken
Wil je AI-systemen bouwen, workflows automatiseren, of je technische infrastructuur opschalen? Ik help je graag.
- Fiverr (maatwerk builds en integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design en branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
