Claude Code /powerup en /insights: Van Nul tot Expert

Claude Code /powerup en /insights: Van Nul tot Expert

Ik had de update-melding bijna overgeslagen. Versie 2.1.90 landde terwijl ik midden in een klantproject zat -- drie agents actief, een deployment-pipeline half afgebouwd, en mijn koffie werd koud. Weer een nieuwe versie van Claude Code. Ze brengen zo snel updates uit dat het bijhouden van elke changelog als een bijbaan voelt.

Maar een vriend stuurde me een bericht: "Voer /insights uit. Vertrouw me."

Dus dat deed ik. En dertig seconden later staarde ik naar een HTML-rapportkaart van mijn laatste 30 dagen met Claude Code -- sessies uitgesplitst per project, talen die ik het meest had gebruikt, tools waar ik op had geleund, knelpunten die ik niet had opgemerkt, en een lijst met workflowfouten die ik herhaaldelijk maakte zonder het te beseffen. Eén regel raakte me hard: ik had handmatig mijn projectcontext opnieuw uitgelegd in 73% van nieuwe sessies in plaats van CLAUDE.md-bestanden te gebruiken. Drieënzeventig procent. Ik schrijf over Claude Code voor mijn werk, en ik verspilde nog steeds tokens aan iets waarvan ik anderen had verteld ermee te stoppen.

Dat was het moment waarop ik besefte dat Claude Code iets werkelijk anders had uitgebracht. Geen nieuwe modelcapaciteit. Geen prestatieverbetering. Een feedbacklus -- en een leersysteem om ermee samen te gaan.

De twee commando's in het centrum hiervan zijn /powerup en /insights. Afzonderlijk is elk nuttig. Samen creëren ze iets dat ik bij geen enkele andere ontwikkelaarstool heb gezien: een gesloten-lus systeem waarin je de basis leert, ze toepast in echt werk, gepersonaliseerde analyses krijgt over hoe je daadwerkelijk presteert, en vervolgens de specifieke dingen leert die je fout doet. Het is het verschil tussen een schoolboek lezen en een tutor hebben die meekijkt terwijl je codeert.

Hier is hoe beide commando's werken, waarom de combinatie meer uitmaakt dan elk afzonderlijk, en hoe ik een automatiseringspipeline heb gebouwd die deze feedbacklus omzet in een zelfverbeterend systeem.

Wat /powerup Werkelijk Doet (En Wat de Meeste Mensen Missen)

Ik heb /powerup uitgebreid behandeld toen het net werd gelanceerd -- je kunt dat volledige eerste overzicht hier lezen. Maar hier is de beknopte versie voor context, plus een paar dingen die ik heb geleerd sinds ik dat stuk schreef.

/powerup is een interactief leersysteem dat direct in de Claude Code-terminal is ingebouwd. Typ het commando en je krijgt een menu van 10 gestructureerde lessen, elk gericht op een specifieke Claude Code-capaciteit. Dit zijn geen documentatielinks. Het zijn begeleide oefeningen die in je daadwerkelijke terminal draaien, met je daadwerkelijke project, die je realtime feedback geven terwijl je elk concept doorwerkt.

De 10 powerups behandelen wat Anthropic beschouwt als de 80/20 van Claude Code-vaardigheid:

• Contextbeheer -- hoe Claude je codebase leest, wat in het contextvenster terechtkomt, en hoe je het beheert met .claudeignore en @-vermeldingen
• Toestemmingsmodi -- begrip van de vertrouwensniveaus (ask, auto-edit, full auto) en wanneer elk zinvol is
• Het /compact commando -- gesprekslengte beheren en waarom compactie niet alleen gaat over tokens besparen
• Hooks en automatisering -- pre/post commando hooks waarmee je het gedrag van Claude Code kunt aanpassen
• Agents en subagents -- de "vermenigvuldig jezelf" powerup, over hoe Claude parallelle werkers aanstuurt
• Aangepaste slash-commando's -- je eigen /commands bouwen vanuit markdown-bestanden
• CLAUDE.md-bestanden -- projectgeheugen dat blijft bestaan tussen sessies
• Toolgebruikpatronen -- hoe Claude beslist welke tools te gebruiken en hoe je die beslissingen kunt sturen
• MCP-serverintegratie -- Claude verbinden met externe tools en databronnen
• Workflow-orchestratie -- alles hierboven combineren tot samenhangende ontwikkelworkflows

Elke les volgt een strakke structuur: conceptintroductie in duidelijke taal, een begeleide praktijkoefening in je terminal, observatie en feedback op wat je deed, en vervolgens een voortgangshook die verbindt met de volgende les. Het hele proces duurt ongeveer 10 minuten per powerup.

Dit is wat de meeste mensen missen: de powerups zijn niet statisch. Ze passen zich aan je projectcontext aan. De contextbeheerles gedraagt zich anders wanneer je in een monorepo met 200 bestanden zit versus een enkel-bestandsscript. De CLAUDE.md-les controleert of je er al een hebt en past zich dienovereenkomstig aan. Dit is geen standaard tutorial -- het is een responsief leersysteem dat je ophaalt waar je bent.

Ik heb de volledige set nu twee keer doorlopen. De tweede keer, drie weken na de eerste, pikte ik nuances op die ik aanvankelijk had overgeslagen -- met name rond hoe .claudeignore-regels opnieuw worden geëvalueerd na een /compact-operatie. Dat ene inzicht bespaarde me een debugsessie die me een uur had gekost.

Maar /powerup heeft een plafond. Het leert je de basis. Het brengt je van nul naar ruwweg 80% vaardigheid. De laatste 20% -- het deel waar je van competent naar werkelijk expert gaat -- vereist iets dat /powerup niet kan bieden: gepersonaliseerde feedback op je daadwerkelijke gebruikspatronen.

Daar komt /insights in beeld.

/insights: De Gepersonaliseerde Rapportkaart Die Je Niet Wist Dat Je Nodig Had

Als /powerup het schoolboek is, dan is /insights de tutor die al een maand naar je scherm kijkt.

Voer /insights uit in je terminal. Wacht ongeveer 30 seconden -- het leest je lokale sessiegeschiedenis, het roept geen API aan. Vervolgens genereert het een interactief HTML-rapport en opent het in je browser. Het rapport wordt opgeslagen in ~/.claude/usage-data/report.html, zodat je het altijd opnieuw kunt bekijken.

Wat er in het rapport stond, schokte me de eerste keer dat ik het zag. Niet omdat de data op totaalniveau verrassend was, maar omdat de specificiteit van de analyse zoveel scherper was dan ik van een ingebouwde tool had verwacht.

Sessie-analyse Uitsplitsing

Het eerste gedeelte brengt je Claude Code-gebruik over de laatste 30 dagen in kaart. Het mijne toonde:

• 142 sessies verspreid over 7 verschillende projecten
• Taalverdeling: TypeScript (47%), Python (23%), Markdown (18%), Bash (12%)
• Meest gebruikte tools: Bash (34% van toolaanroepen), Read (28%), Edit (22%), Write (10%), Glob (6%)
• Gemiddelde sessieduur: 23 minuten
• Gemiddelde reactietijd gebruiker: 8,4 seconden

Deze cijfers alleen al vertelden me iets dat ik niet bewust had geregistreerd: ik besteedde bijna een vijfde van mijn Claude Code-tijd aan het schrijven van Markdown. Dat is contentcreatie -- blogposts, documentatie, CLAUDE.md-bestanden. Niet coderen. Niet per se een probleem, maar het deed me heroverwegen of mijn workflow zo code-intensief was als ik aannam.

Wat Goed Werkt

Het rapport identificeert je sterke punten -- patronen waarbij je Claude Code effectief gebruikt. Het mijne benadrukte mijn CLAUDE.md-discipline (aanwezig in 6 van 7 actieve projecten), consistent gebruik van /compact om context te beheren, en effectieve agentdelegatiepatronen in mijn grotere projecten.

Dit gedeelte is belangrijker dan je zou denken. Positieve bevestiging van een tool klinkt triviaal, maar weten welke gewoonten je moet behouden is net zo waardevol als weten welke je moet corrigeren.

Waar Je Tijd Verliest

Dit is het gedeelte dat pijn doet. En dat hoort ook.

Mijn rapport markeerde drie knelpunten:

1. Herhaalde contextuitleg. In 73% van nieuwe sessies besteedde ik de eerste 2-3 berichten aan het uitleggen waar ik mee bezig was, in plaats van CLAUDE.md het te laten afhandelen. De ironie ontging me niet -- ik heb letterlijk een blogpost waarin ik mensen vertel CLAUDE.md-bestanden goed te gebruiken.

2. Foutieve diagnoselussen. In ongeveer 15% van mijn debugsessies joegen Claude en ik een hypothese na die onjuist bleek te zijn, waarbij we 8-12 berichten verbrandden voordat we een andere richting insloegen. Het rapport suggereerde dat ik debugsessies begin met Claude te vragen drie mogelijke oorzaken op te sommen, gerangschikt op waarschijnlijkheid, voordat ik er eentje onderzoek.

3. Onderbenutting van subagents. Ik voerde sequentiële taken uit die geparallelliseerd hadden kunnen worden. Het rapport schatte dat ik 20-30% kon besparen op mijn langere sessies door onafhankelijke subtaken aan subagents te delegeren.

Elk knelpunt kwam met specifieke voorbeelden uit mijn sessiegeschiedenis en een concrete aanbeveling. Geen vage adviezen. Specifieke veranderingen die ik onmiddellijk kon doorvoeren.

Snelle Resultaten en Ambitieuze Suggesties

Het rapport biedt twee niveaus van aanbevelingen: snelle resultaten die je in minder dan vijf minuten kunt implementeren, en ambitieuze workflowwijzigingen die meer opzet vereisen maar grotere opbrengsten beloven.

Mijn snelle resultaten omvatten het toevoegen van een pre-commit hook om automatisch linting uit te voeren (wat me bespaarde om Claude herhaaldelijk te vragen opmaak te corrigeren), en het maken van een aangepast /debug slash-commando dat het "drie hypothesen eerst"-patroon afdwingt dat het rapport had geïdentificeerd als ontbrekend bij mij.

De ambitieuze suggestie was interessanter: het rapport adviseerde me een aangepaste skill te bouwen die /insights-analyse combineert met geautomatiseerde CLAUDE.md-updates -- in wezen Claude Code zijn eigen projectgeheugen laten verbeteren op basis van patronen die het detecteert in mijn gebruik. Ik kom hier terug op in het automatiseringsgedeelte, want ik heb het daadwerkelijk gebouwd.

Veelvoorkomende Fouten en Patronen

Het foutengedeelte van mijn rapport was vernederend. Het toonde een terugkerend patroon van mislukte assetgeneratie in één project -- ik had Claude gevraagd afbeeldingsbestanden te maken in contexten waar het dat niet kon, en herprompttte dan in plaats van over te schakelen naar een tool die het daadwerkelijk aankon. Het rapport wees dit aan met tijdstempels en sessie-ID's. Nergens om je te verbergen.

Het identificeerde ook dat mijn TypeScript-sessies een hoger foutpercentage hadden dan mijn Python-sessies, herleid tot de gewoonte om niet vooraf strikte TypeScript-compileropties te specificeren, waardoor Claude code genereerde die in losse modus slaagde maar in mijn CI-pipeline faalde.

Privacy: Alles Blijft Lokaal

Een detail dat de moeite waard is om te benadrukken: /insights stuurt je data nergens heen. De analyse draait volledig op je lokale machine en leest sessielogs die zijn opgeslagen in ~/.claude/. Het HTML-rapport wordt lokaal gegenereerd en lokaal opgeslagen. Als je aan gevoelige code werkt -- klantprojecten, propriëtaire systemen, alles onder NDA -- dan maakt dit uit. Je gebruikspatronen, sessie-inhoud en het gegenereerde rapport verlaten nooit je machine.

Je kunt ook persoonlijke gegevens uit het rapport verwijderen voordat je het deelt met een team of extern opslaat. Het rapport bevat een privacyknop die projectnamen, bestandspaden en specifieke codereferenties verwijdert terwijl de analytische inzichten behouden blijven.

Dit is precies waar /insights zich onderscheidt van externe analysetools. Geen telemetrie. Geen cloudverwerking. Geen "vertrouw ons met je data"-afspraak. Gewoon lokale analyse van lokale logs.

Het Vliegwiel: Waarom /powerup + /insights Samen Beter Zijn Dan Elk Apart

Hier is het inzicht dat veranderde hoe ik over deze commando's denk -- en eerlijk gezegd, hoe ik denk over het leren van ontwikkelaarstools in het algemeen.

/powerup en /insights zijn niet zomaar twee functies. Het zijn twee helften van een leercyclus.

Denk na over hoe vaardigheidsontwikkeling echt werkt. Je hebt twee dingen nodig: instructie (iemand die je leert hoe je iets doet) en feedback (iemand die je vertelt hoe goed je het daadwerkelijk doet). De meeste ontwikkelaarstools geven je het een of het ander. Documentatie geeft je instructie. Foutlogs geven je feedback. Maar ze zijn losgekoppeld. Je leest de docs, probeert dingen, faalt op manieren waar de docs je niet op hadden voorbereid, en worstelt je erdoorheen.

Claude Code 2.1.90 sluit die lus binnen één enkel gereedschap:

1. Voer /powerup uit -- Leer de basis. Bouw je mentale model van hoe contextbeheer, toestemmingen, subagents en hooks werken.
2. Gebruik Claude Code voor echt werk -- Pas toe wat je hebt geleerd in daadwerkelijke projecten gedurende 2-4 weken.
3. Voer /insights uit -- Krijg een gepersonaliseerde analyse van hoe je die capaciteiten daadwerkelijk gebruikt. Ontdek welke basisvaardigheden je goed toepast en welke je verwaarloost of verkeerd gebruikt.
4. Ga terug naar /powerup -- Bekijk de specifieke lessen die overeenkomen met je zwakke punten opnieuw. De contextbeheer-powerup voelt anders aan nadat je data hebt gezien die aantoont dat je context opnieuw uitlegt in 73% van sessies.
5. Herhaal.

Dit is de cyclus die je brengt van 0% naar 80% (via /powerup) en vervolgens van 80% naar echt meesterschap (via /insights). Elke rotatie van het vliegwiel maakt je workflow strakker, elimineert frictie en brengt de volgende laag van optimalisatie aan het licht.

Ik heb deze cyclus nu twee keer doorlopen. De eerste rotatie was het meest dramatisch -- het corrigeren van de contextheruitleg-gewoonte alleen al bespaart me waarschijnlijk 15-20 minuten per dag. De tweede rotatie was subtieler maar nog steeds waardevol, waarbij een toolgebruikpatroon werd ontdekt dat ik niet had opgemerkt (overmatig gebruik van Bash voor bestandsoperaties terwijl Read en Glob sneller en betrouwbaarder zijn).

De meeste mensen zullen /powerup één keer uitvoeren, /insights één keer uitvoeren, en verder gaan. Dat is prima -- je krijgt nog steeds waarde. Maar de echte kracht toont zich bij de tweede en derde rotatie, wanneer je je verbetering weerspiegeld ziet in de data.

De Automatiseringspipeline Bouwen: Van Handmatig naar Zelfverbeterend

Hier wordt het echt krachtig. Na mijn tweede cyclus door /powerup en /insights, had ik een gedachte: waarom doe ik dit handmatig?

Het /insights-rapport genereert gestructureerde aanbevelingen. Die aanbevelingen kunnen programmatisch worden geëxtraheerd. De geëxtraheerde inzichten kunnen ergens persistent worden opgeslagen. En het geheel kan op een schema draaien.

Dus ik heb het gebouwd. Hier is de complete pipeline.

Stap 1: Genereer het Insights-Rapport Programmatisch

Je hoeft /insights niet interactief in te typen. De headless-modus van Claude Code laat je het vanuit een script triggeren:

# Genereer insights-rapport in niet-interactieve modus
claude -p "/insights" --output-format json > /tmp/insights-raw.json

De --output-format json vlag geeft je gestructureerde data in plaats van het HTML-rapport. Dit is de basis van elke automatisering -- je hebt machine-leesbare output nodig.

Stap 2: Extraheer Actiegerichte Aanbevelingen

Zodra je de ruwe insights-data hebt, kun je het terugvoeren naar Claude Code voor extractie:

# Extraheer knelpunten en aanbevelingen
claude -p "Lees /tmp/insights-raw.json. Extraheer:
1. Top 3 knelpunten met specifieke voorbeelden
2. Snelle resultaten (implementeerbaar in minder dan 5 minuten)
3. Voorgestelde CLAUDE.md-regeltoevoegingen
4. Toolgebruikpatronen om te wijzigen

Formatteer als gestructureerde markdown." > /tmp/insights-summary.md

Dit geeft je een schone, actiegerichte samenvatting zonder het volledige detail van het HTML-rapport. Het is de beknopte briefingversie.

Stap 3: Bewaar in Obsidian voor Persistent Kennis

Als je Obsidian gebruikt -- en als je mijn handleiding voor het bouwen van een second brain met Claude Code en Obsidian hebt gelezen, weet je waarom ik vind dat je dat zou moeten doen -- gaat de samenvatting rechtstreeks naar je vault:

# Definieer paden
VAULT_PATH="$HOME/obsidian-vault"
INSIGHTS_DIR="$VAULT_PATH/Claude-Code-Insights"
DATE=$(date +%Y-%m-%d)

# Zorg ervoor dat de map bestaat
mkdir -p "$INSIGHTS_DIR"

# Kopieer de samenvatting met een gedateerde bestandsnaam
cp /tmp/insights-summary.md "$INSIGHTS_DIR/$DATE-insights.md"

# Voeg frontmatter toe voor Obsidian
cat > "$INSIGHTS_DIR/$DATE-insights.md" << EOF
---
date: $DATE
type: claude-insights
tags: [claude-code, workflow-analytics, self-improvement]
---

# Claude Code Insights - $DATE

$(cat /tmp/insights-summary.md)
EOF

Nu heeft je Obsidian-vault een gedateerd verslag van elke insights-analyse. Na verloop van tijd wordt dit een longitudinaal overzicht van je groei -- je kunt zien welke knelpunten je hebt geëlimineerd en welke blijven terugkeren.

Stap 4: Werk CLAUDE.md-Regels Automatisch Bij

Dit is het deel dat als magie voelt. Het /insights-rapport genereert voorgestelde CLAUDE.md-regels op basis van je patronen. Je kunt deze automatisch samenvoegen met het geheugen van je project:

# Extraheer en voeg nieuwe CLAUDE.md-regels toe
claude -p "Lees /tmp/insights-summary.md.
Extraheer alle voorgestelde CLAUDE.md-regels.
Vergelijk met de bestaande CLAUDE.md in het huidige project.
Voeg alleen regels toe die niet dupliceren met bestaande.
Bewaar alle bestaande inhoud." \
  --allowedTools "Read,Edit"

Ik voer dit maandelijks uit. Elke keer voegt het doorgaans 1-3 nieuwe regels toe op basis van patronen die /insights heeft gedetecteerd. Mijn CLAUDE.md-bestanden worden slimmer zonder dat ik ze handmatig onderhoud.

Stap 5: Plan het Geheel In

Het laatste stukje: dit automatisch laten draaien. Het /schedule-commando van Claude Code handelt terugkerende taken af:

# Plan maandelijkse insights-analyse
# Draait op de 1e van elke maand om 9 uur
claude -p "/schedule create --name 'monthly-insights' \
  --cron '0 9 1 * *' \
  --command 'Voer /insights uit, extraheer aanbevelingen, \
  sla samenvatting op in ~/obsidian-vault/Claude-Code-Insights/, \
  en mail me de belangrijkste bevindingen'"

Je kunt ook /loop gebruiken voor frequentere controles tijdens intensieve ontwikkelperiodes:

# Tijdens een sprint: genereer wekelijks insights
claude -p "/loop 7d /insights"

Stap 6 (Optioneel): Mail de Samenvatting

Als je de insights in je inbox wilt ontvangen, kun je de samenvatting doorsturen via Google Workspace CLI of een andere e-mailtool:

# Verstuur insights-samenvatting via e-mail
claude -p "Lees /tmp/insights-summary.md en verstuur het als een e-mail
naar [email protected] met onderwerp 'Claude Code Insights - $DATE'.
Gebruik een schoon, leesbaar formaat.
Verwijder eerst alle gevoelige projectnamen of bestandspaden."

De volledige pipeline -- van het genereren van insights tot opslaan in Obsidian tot het e-mailen van een samenvatting -- draait in minder dan twee minuten. Ik voer het maandelijks uit sinds februari 2026, en de Obsidian-vault bevat nu drie maanden aan insights-geschiedenis. De trendlijn is zichtbaar: mijn debugefficiëntie is meetbaar verbeterd, mijn contextheruitleg-percentage daalde van 73% naar ongeveer 12%, en mijn subagent-gebruik ging van "bijna nooit" naar "standaard voor elke taak met twee of meer onafhankelijke subtaken."

Als je liever hebt dat iemand deze automatiseringsopstelling helemaal voor je bouwt, neem ik Claude Code-integratieprojecten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

De Skill Die Alles Samenbrengt

Na het bouwen van de pipeline realiseerde ik me dat ik het nog steeds aanriep via een reeks handmatige bash-commando's. De volgende logische stap was de hele workflow verpakken in een aangepaste Claude Code-skill.

Hier is de skill die ik heb gemaakt -- een markdown-bestand geplaatst in ~/.claude/commands/:

# insights-to-obsidian.md

Voer het /insights-commando uit en analyseer de resultaten.
Extraheer:
1. Top 3 knelpunten met concrete voorbeelden
2. Alle aanbevelingen voor snelle resultaten
3. Voorgestelde CLAUDE.md-regeltoevoegingen
4. Suggesties voor toolgebruikoptimalisatie
5. Indrukwekkende prestaties die het waard zijn om te documenteren

Sla een gestructureerde samenvatting op in mijn Obsidian-vault op:
~/obsidian-vault/Claude-Code-Insights/YYYY-MM-DD-insights.md

Voeg frontmatter toe met datum, type: claude-insights, en relevante tags.

Stel na het opslaan een korte e-mailsamenvatting op (minder dan 300 woorden)
die de belangrijkste bevindingen behandelt en verstuur het via Gmail.

Verwijder vóór het opslaan alle gevoelige projectnamen, bestandspaden
of klantspecifieke informatie uit de output.

Nu draait de hele pipeline met één commando: /project:insights-to-obsidian. Eén aanroep. Twee minuten. Complete analyse, persistente opslag en e-mailnotificatie.

Dit is wat ik bedoel als ik spreek over Claude Code dat systemen bouwt die zichzelf verbeteren. De tool analyseert je gedrag, genereert aanbevelingen, slaat die aanbevelingen op in je kennisbank, en werkt zijn eigen configuratiebestanden bij op basis van wat het heeft geleerd. Je gebruikt niet zomaar een code-editor met AI-autocomplete. Je draait een zelfverbeterende ontwikkelomgeving.

Wat /insights Fout Doet (En Wat Ik Wou Dat Het Beter Deed)

Geen toolreview is compleet zonder de eerlijke beoordeling, en /insights heeft ruwe kantjes die de moeite waard zijn om te kennen.

Het 30-dagenvenster ligt vast. Je kunt de terugkijkperiode niet aanpassen. Als je alleen de laatste week wilt analyseren (nuttig tijdens intensieve sprints) of het laatste kwartaal (nuttig voor het grote plaatje), heb je pech. Het rapport dekt altijd precies 30 dagen. Ik heb dit opgelost door het maandelijks uit te voeren en rapporten in Obsidian te vergelijken, maar een configureerbaar venster zou een aanzienlijke verbetering zijn.

De kwaliteit van aanbevelingen varieert. Sommige suggesties zijn echt uitvoerbaar -- "voeg deze specifieke regel toe aan je CLAUDE.md" met de exacte tekst klaar om te plakken. Andere zijn vaag genoeg om frustrerend te zijn -- "overweeg vaker subagents te gebruiken" zonder te specificeren welke van je workflows er het meest van zou profiteren. De eerste categorie is goud. De tweede categorie heeft werk nodig.

Grote sessievolumes vertragen het. Als je een intensieve gebruiker bent (150+ sessies in 30 dagen), kan de analyse 45-60 seconden duren in plaats van de gebruikelijke 30. Geen dealbreaker, maar merkbaar. De HTML-rapportweergave kan ook vertragen met zoveel data.

Geen team-level insights. Als je met een team werkt en geaggregeerde patronen wilt zien -- welke teamleden subagents effectief gebruiken, waar het team collectief tijd verliest -- moet je dat zelf bouwen. De analytische tracking in Claude Code's documentatie dekt team-gebruiksstatistieken, maar /insights is strikt individueel.

Geen diff tussen rapporten. Wanneer je /insights een tweede keer uitvoert, krijg je een vers rapport zonder verwijzing naar het vorige. Ik wil zien: "Vorige maand had je een contextheruitleg-percentage van 73%. Deze maand is het 12%. Dit is wat er veranderde." Ik simuleer dit via Obsidian-vergelijkingen, maar native diff-ondersteuning zou het vliegwiel sneller laten draaien.

Ondanks deze beperkingen is /insights nog steeds de meest nuttige zelfevaluatietool die ik in welke ontwikkelomgeving dan ook heb gebruikt. De knelpunten die het identificeerde waren echt, de aanbevelingen waren grotendeels uitvoerbaar, en het lokaal-enige privacymodel betekent dat ik niet twee keer hoef na te denken voordat ik het op klantprojecten uitvoer.

De Versievereiste: Zorg Ervoor Dat Je op 2.1.90+ Zit

Beide commando's vereisen Claude Code versie 2.1.90 of later. Controleer je versie:

claude --version

Als je achterloopt, werk dan bij:

claude update

Of als je via npm hebt geïnstalleerd:

npm install -g @anthropic-ai/claude-code@latest

Het /powerup-commando was technisch beschikbaar in eerdere builds als experimentele functie, maar de volledige set van 10 lessen en het adaptieve oefensysteem werden pas met 2.1.90 uitgebracht. Het /insights-commando is volledig nieuw in deze versie.

Iets om op te letten: als je op een teamplan met beheerde implementaties zit, moet je beheerder mogelijk de update goedkeuren. Ik heb van een paar lezers gehoord wier organisaties Claude Code-versies vastzetten voor stabiliteit. Als dat jij bent, praat met degene die je tooling beheert -- deze update is het waard om voor te pushen.

Veelgestelde Vragen

Stuurt /insights mijn code of sessiedata naar de servers van Anthropic?

Nee. Het /insights-commando verwerkt alles lokaal met behulp van sessielogs die zijn opgeslagen in ~/.claude/ op je machine. Het gegenereerde HTML-rapport wordt lokaal opgeslagen in ~/.claude/usage-data/report.html. Er verlaten geen data je computer tijdens de analyse. Je kunt dit verifiëren door het commando uit te voeren met netwerkmonitoring actief.

Kan ik /powerup uitvoeren zonder een project open te hebben?

Ja, maar de ervaring is anders. Sommige powerups -- zoals contextbeheer en CLAUDE.md-lessen -- passen hun oefeningen aan op basis van je huidige projectstructuur. Ze uitvoeren in een lege map geeft je de concepten maar mist de gepersonaliseerde demonstraties. Voor de beste ervaring, open eerst een echt project.

Hoe vaak moet ik /insights uitvoeren?

Maandelijks is het optimale punt voor de meeste ontwikkelaars. Vaker uitvoeren geeft niet genoeg nieuwe data om betekenisvolle patronen te ontdekken, en minder vaak uitvoeren betekent dat knelpunten langer blijven bestaan dan nodig. Tijdens intensieve sprints kunnen wekelijkse runs via /loop 7d /insights opkomende slechte gewoonten opvangen voordat ze zich vestigen.

Wat is het verschil tussen /insights en de teamanalytics van Claude Code?

Het /insights-commando is persoonlijk -- het analyseert je individuele gebruikspatronen en genereert aanbevelingen voor je workflow. De teamanalytics van Claude Code (gedocumenteerd op code.claude.com/docs/en/analytics) volgen geaggregeerde teamstatistieken zoals totale sessies, modelgebruik en kostenverdeling. Ze dienen verschillende doelen: /insights is een coachingtool, teamanalytics is een managementtool.

Kan ik mijn /insights-rapport delen met mijn team?

Ja, met de privacyverwijderoptie. Het rapport bevat een schakelaar om projectnamen, bestandspaden en specifieke codereferenties te verwijderen terwijl de analytische inzichten behouden blijven. Hiermee kun je workflowpatronen en aanbevelingen delen zonder gevoelige projectdetails bloot te geven.

Laten We Samenwerken

Ben je op zoek naar het bouwen van AI-systemen, het automatiseren van workflows, of het opschalen van je technische infrastructuur? Ik help je graag.

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