Claude Code is nu angstaanjagend goed — dit is waarom
Afgelopen dinsdag had ik bijna drie custom scripts verwijderd. Niet omdat ze kapot waren — maar omdat de nieuwste update van Claude Code ze van de ene op de andere dag volledig overbodig maakte.
Ik had weken besteed aan het finetunen van shell-aliassen, het bouwen van wrapper-functies rond API-aanroepen en het opzetten van een Slack-notificatiepijplijn voor mijn deployment-workflow. Goed werk. Solide engineering. Toen bracht Anthropic deze update uit en zat ik toe te kijken hoe Claude Code alles deed wat mijn scripts deden — plus dingen waar ik niet eens aan had gedacht — rechtstreeks vanuit de terminal.
Dat is een vreemd gevoel. Tegelijkertijd "dit is geweldig" en "wat is er net met mijn weekendproject gebeurd."
Dit is wat ik weet na een volle week stresstesten van elke nieuwe functie: dit is geen kleine patch. Anthropic heeft fundamenteel veranderd wat Claude Code kan doen, en als je nu iets bouwt met AI-agents, moet je begrijpen wat er verschoven is. Sommige van deze functies zullen je dagelijkse werkwijze veranderen. Eén ervan — en daar kom ik nog op terug — verandert misschien hoe je over AI-vaardigheden denkt.
Maar eerst degene die mij het hardst raakte.
De Skill Creator veranderde mijn agents in zelfverbeterende systemen
Ik bouw al custom skills voor Claude Code sinds het begin. Het proces was altijd hetzelfde: een skilldefinitie schrijven, handmatig testen, de prompt aanpassen, opnieuw testen, deployen, ontdekken dat het iets anders kapotmaakte, en dan dagenlang herhalen. Functioneel? Zeker. Efficiënt? Absoluut niet.
De vernieuwde skill creator verandert deze cyclus volledig. En ik bedoel niet dat het een mooiere interface heeft gekregen — ik bedoel dat het ingebouwde evol-generatie met benchmarking en multi-agent testing heeft geïntroduceerd. Die woorden klinken misschien als marketingtaal, maar blijf even lezen, want dit is echt anders.
Dit is wat het in de praktijk betekent. Je schrijft een skill, en in plaats van deze handmatig tegen verschillende scenario's te testen, kun je nu wat Anthropic "evol tests" noemt genereren — geautomatiseerde benchmarks die slagingspercentages, runtime en tokengebruik meten over meerdere testscenario's. De skill creator start meerdere agents, werpt je skill tegen verschillende randgevallen en geeft je harde cijfers over hoe het presteert.
Ik testte dit met een PDF-formulierinvulskill waar ik al weken mee worstelde. De originele versie haalde tekst uit formuliervelden en vulde ze in, maar bleef data verkeerd uitlijnen — adressen in telefoonnummervelden plaatsen, dat soort chaos. Handmatig debuggen kwam nergens, omdat de fouten inconsistent waren.
Met de nieuwe skill creator voerde ik een evol-test uit en zag meteen het probleem: mijn tekstextractie was niet verankerd aan precieze coördinaten. De skill raadde veldposities op basis van labels, en labelpositionering varieerde per PDF-template. De benchmarkdata toonde een slagingspercentage van 62% — veel slechter dan ik had aangenomen op basis van mijn handvol handmatige tests.
De oplossing was eenvoudig zodra ik de data kon zien. Ik verankerde extractie aan exacte coördinaten in plaats van fuzzy labelvergelijking. Het slagingspercentage sprong naar 94% bij de volgende evol-run. Wat me nog een week handmatig debuggen zou hebben gekost, kostte ongeveer veertig minuten met daadwerkelijke metrics als leidraad.
Maar hier is het deel dat echt mijn aandacht trok — en dit sluit aan bij iets wat ik je in het implementatiegedeelte laat zien. Skills kunnen nu automatisch evolueren wanneer er nieuwe modellen uitkomen. Dus wanneer Anthropic een modelupdate uitbrengt, blijven je skills niet gewoon op hetzelfde niveau werken. Ze kunnen zich aanpassen en mogelijk verbeteren zonder dat je ze aanraakt. Ik was altijd bang voor modelupdates omdat de helft van mijn prompts herschreven moest worden. Die frictie is nu grotendeels verdwenen.
Ultra Mode en waarom ik me geen zorgen meer maak over complexe codebases
Ik zal eerlijk zijn — toen Ultra Mode maanden geleden voor het eerst verscheen, dacht ik dat het vooral hype was. Groter redeneerbudget, langere denktijd, prima. Maar leverde het daadwerkelijk betekenisvol betere output op?
Na deze update: ja. Ondubbelzinnig ja.
Ultra Mode ondersteunt nu Opus 4.6 en Sonnet 4.6, en het verschil is niet subtiel. Het uitgebreide redeneerbudget betekent dat Claude Code grotere delen van je codebase in zijn werkgeheugen kan houden tijdens het oplossen van problemen. Voor kleine scripts en bewerkingen in één bestand merk je weinig verschil. Voor alles wat meerdere bestanden raakt, complexe state management of stapsgewijs debuggen — het is een totaal andere ervaring.
Ik onderwierp het aan de zwaarste test die ik kon bedenken: het bouwen van een volledige full-stack kalendertoepassing vanuit het niets. React frontend, TypeScript overal, goede componentarchitectuur, state management, API-integratie. Geen speelgoeddemo — een echte applicatie met terugkerende evenementen, tijdzone-afhandeling, drag-and-drop herplannen.
Met standaard modus verloor Claude Code af en toe de context tussen componenten. Het genereerde een prachtig EventCard-component en maakte vervolgens een CalendarGrid dat net iets andere props verwachtte. Kleine mismatches die ik in de review ontdekte en handmatig repareerde. Normale AI-codeerervaring.
Met Ultra Mode actief (je schakelt het in door ultrathink te typen in Claude Code) verdwenen die mismatches vrijwel geheel. De gegenereerde componenten pasten naadloos in elkaar omdat het model genoeg redeneerruimte had om de hele componentboom tegelijk in gedachten te houden. De kalender-app kwam eruit met consistente prop-interfaces, correcte TypeScript-types door de hele stack, en zelfs verstandige error boundaries waar ik niet expliciet om had gevraagd.
Kost het meer tokens? Absoluut. Is het langzamer? Een beetje. Waard voor complex werk? Zonder twijfel. Ik ben standaard Ultra Mode gaan gebruiken voor alles wat verder gaat dan bewerkingen in één bestand, en mijn review-en-fix-cycli zijn drastisch afgenomen.
Er is wel een praktische afweging die ik moet noemen. Ultra Mode verbruikt je API-budget sneller. Voor een complexe sessie bij het bouwen van die kalender-app gebruikte ik ruwweg 3x zoveel tokens vergeleken met de standaard modus. Als je een krap budget hebt, bewaar Ultra Mode voor werk dat het echt nodig heeft — multi-bestandsrefactors, complex debuggen, architectuurbeslissingen. Gebruik de standaard modus voor snelle bewerkingen en eenvoudige generaties.
Die budgetoverweging leidt natuurlijk naar de volgende functie, want Anthropic heeft duidelijk nagedacht over hoe mensen Claude Code daadwerkelijk gebruiken gedurende hun dag — niet alleen wanneer ze achter een bureau zitten.
Remote Control: mijn telefoon werd een build-dashboard
Deze verraste me meer dan al het andere in de update. Remote control laat je Claude Code-sessies starten, monitoren en ermee communiceren vanaf je telefoon of elk ander secundair apparaat. Beschikbaar voor alle betaalde Anthropic-abonnementen, geen extra configuratie nodig.
Mijn eerste gedachte was "dat is een gimmick." Mijn tweede gedachte, na drie dagen gebruik, was "hoe heb ik ooit zonder dit geleefd?"
Dit is mijn werkelijke use case. Ik startte een grote refactoringtaak voordat ik naar een vergadering vertrok — het reorganiseren van gedeelde hulpprogramma's in een monorepo naar nette packages. Het soort taak waarbij Claude Code honderden bestandswijzigingen moet maken in tientallen mappen. Voorheen wachtte ik aan mijn bureau tot het klaar was, of ik kwam terug om te ontdekken dat het veertig minuten geleden een fout had gehad en was gestopt.
Met remote control volgde ik de voortgang op mijn telefoon tijdens de vergadering. Toen Claude Code een dubbelzinnig importpad tegenkwam en om verduidelijking vroeg, reageerde ik vanaf mijn telefoon in ongeveer vijftien seconden. De refactor ging door. Tegen de tijd dat ik terug was achter mijn bureau, was de hele reorganisatie klaar en slaagden alle tests.
Ik gebruikte het ook voor iets eenvoudigers maar even nuttigs: het monitoren van langlopende testsuites. Start de tests vanuit Claude Code, loop weg, krijg een melding op je telefoon als ze klaar zijn of falen. Het verandert Claude Code van een "achter je bureau"-tool in iets dat rond jouw planning werkt.
Een beperking die het weten waard is: complexe interacties — zoals het reviewen van grote diffs of het schrijven van gedetailleerde prompts — gaan nog steeds beter met een volledig toetsenbord. De telefooninterface werkt prima voor goedkeuringen, korte antwoorden en monitoring. Verwacht niet om diepe codeersessies vanaf je telefoon te doen. Dat is niet het doel, en eerlijk gezegd zou het dat ook niet moeten zijn.
Voice Mode veranderde hoe ik over prompting denk
Op dit moment heeft slechts ongeveer 5% van de gebruikers toegang tot voice mode, en ik zat toevallig in die groep. Je activeert het door /voice te typen in je Claude Code-sessie; het schakelt realtime spraak-naar-tekst transcriptie in voor je opdrachten.
Mijn aanvankelijke reactie was scepsis. Ik typ snel. Waarom zou ik tegen mijn terminal praten?
Drie dagen later begreep ik het. De waarde zit niet in snelheid — het zit in expressiviteit.
Wanneer ik een prompt typ, ben ik geneigd beknopt te zijn. "Refactor de auth-middleware om token refresh af te handelen." Schoon, precies, efficiënt. Maar ook zonder context die Claude Code zou helpen betere beslissingen te nemen.
Wanneer ik spreek, voeg ik die context van nature toe: "Hé, dus de auth-middleware wordt rommelig omdat we token refresh vorige sprint hebben toegevoegd maar het is verstrengeld met de sessievalidatielogica. Ik wil de refresh-flow naar zijn eigen middleware verplaatsen die vóór de sessiecontrole draait, en ervoor zorgen dat we het token-endpoint niet meer dan één keer per requestcyclus aanroepen."
Hetzelfde verzoek. Veel meer context. Dramatisch betere output van Claude Code omdat het niet alleen begreep wát ik wilde, maar waaróm.
Ik ben voice mode specifiek gaan gebruiken voor complexe architectuurverzoeken waar context ertoe doet, en typen voor snelle, precieze bewerkingen. De hybride aanpak werkt beter dan beide methoden alleen.
De transcriptienauwkeurigheid is goed — het gaat beter met technische termen zoals "middleware," "TypeScript" en specifieke packagenamen dan ik had verwacht. Niet perfect, maar goed genoeg dat ik het zelden hoef te corrigeren. Ik merkte wel dat het af en toe moeite heeft met variabelenamen die klinken als gewone woorden. Kleine frictie.
Als je nog geen toegang hebt, is het de moeite waard om het aan te vragen. En terwijl je wacht, is er een functie die nu al beschikbaar is en direct invloed heeft op hoe snel je met externe API's kunt bouwen.
De Claude API Skill elimineerde mijn documentatie-tabprobleem
Ik had altijd drie browsertabs open: één voor Anthropic's API-docs, één voor de benodigde SDK-referentie en één voor Stack Overflow. De Claude API-skill maakt minstens twee van die tabs overbodig.
Dit is wat het doet. Wanneer je code schrijft die communiceert met de Claude API — of eigenlijk elke ondersteunde API — detecteert de skill automatisch je programmeertaal en selecteert de beste interface (directe API, tool use of SDK). Vervolgens laadt het de relevante documentatie direct in je codeersessie.
Geen samenvatting. Geen "hier is een link." De daadwerkelijke documentatiecontext, beschikbaar terwijl het model aan je code werkt.
Ik was vorige week een batch-verwerkingspijplijn aan het bouwen in Python. In plaats van naar de browser te schakelen om het batch API-endpointformaat op te zoeken, beschreef ik gewoon wat ik nodig had in Claude Code. De API-skill detecteerde dat ik met Python werkte, haalde de Anthropic SDK-docs voor batchverzoeken op en genereerde werkende code inclusief correcte foutafhandeling, retry-logica en rate limiting — allemaal gebaseerd op actuele documentatie, niet op trainingsdata die verouderd zou kunnen zijn.
Het verwerkt streaming-responses, gestructureerde outputs, tool use-configuraties en modelspecifieke standaardwaarden. Het belangrijkste voordeel is het elimineren van context switching. Elke keer dat je alt-tab doet naar een documentatiepagina, verlies je een paar seconden focus. Over een volledige codeersessie telt dat op tot aanzienlijke cognitieve overhead. De docs ingebed hebben in de codeercontext neemt die frictie volledig weg.
Eén ding dat ik waardeer: het is slim met modelstandaardwaarden. Toen ik Opus 4.6 als mijn doelmodel specificeerde, paste de skill automatisch de tokenlimieten, prijsschattingen en beschikbare functies aan in zijn suggesties. Klein detail, maar het voorkwam dat ik code schreef die uitgaat van mogelijkheden die het model niet heeft.
Oké — als je tot hier hebt meegelezen, heb je al een goed begrip van de belangrijkste functies. De volgende twee zijn kleiner maar presteren boven hun gewicht in dagelijkse workflowverbetering.
Het Simplify-commando ontdekte fouten die ik had gemist
Na elke codewijzigingssessie activeert het uitvoeren van /simplify een geautomatiseerde review van je gewijzigde code. Het scant op gedupliceerde logica, herbruikbare patronen, naamgevingsinconsistenties, onnodige complexiteit en structurele problemen.
Ik was sceptisch. Code review is genuanceerd werk — kan een geautomatiseerde pass echt betekenisvolle problemen vinden?
Het ontdekte bij mijn tweede test iets dat een productiebug zou hebben veroorzaakt.
Ik had een datavalidatiemodule gerefactord en in het proces twee bijna identieke validatiefuncties gecreëerd — één in de gebruikersservice en één in de bestelservice. Dezelfde logica, andere variabelenamen. Het soort duplicatie dat van nature ontstaat wanneer je snel werkt en gefocust bent op het laten slagen van tests.
Het simplify-commando markeerde beide functies, toonde me de overlap en stelde voor om een gedeelde validator te extraheren. Nadat ik de fix had goedgekeurd, merkte het ook op dat mijn foutmeldingen inconsistente opmaak gebruikten — sommige hadden foutcodes, andere niet. Geen bug, maar het soort inconsistentie dat verwarring creëert in logs.
De standaard routing-agent voor simplify lijkt Haiku 4.5 te zijn, wat betekent dat het snel en goedkoop draait. Ik ben het als gewoonte gaan gebruiken na elke significante codewijzigingssessie. Zie het als een eerste code review voordat je menselijke reviewers de PR zien. Het zal geen architectuurproblemen vinden of je ontwerpbeslissingen in twijfel trekken, maar het is uitstekend in oppervlaktekwaliteit — de dingen die makkelijk te missen zijn wanneer je diep in probleemoplossing zit.
Protip: voer /simplify uit vóór het committen, niet erna. Duplicatie en naamgevingsproblemen oplossen voordat ze in je git-geschiedenis terechtkomen, houdt je commits schoner en je reviewers tevredener.
Dit past mooi bij de laatste grote functie — want schone code betekent niets als je team er niet effectief over kan communiceren.
Slack-integratie maakte Claude Code een teamspeler
Ik leid een klein gedistribueerd team en onze coördinatie leeft in Slack. Voorheen betekende het delen van Claude Code-context met teamgenoten: terminaloutput kopiëren, in Slack plakken, opmaak verliezen en dan uitleggen wat de output betekende. Op zijn best onhandig.
De nieuwe Slack-plugin verbindt Claude Code direct met je Slack-werkruimte. Je kunt berichten zoeken, updates sturen, documenten aanmaken en Slack-context in je codeersessie binnenhalen zonder de terminal te verlaten.
Hier hielp het me deze week daadwerkelijk. Een teamgenoot postte een bugreport in ons #backend-issues kanaal met een stacktrace en wat context over wanneer het begon. In plaats van de stacktrace handmatig naar Claude Code te kopiëren, haalde ik het Slack-bericht direct in mijn sessie. Claude Code had de volledige context — de stacktrace, de beschrijving van de teamgenoot en de threaddiscussie waar een andere ontwikkelaar een recente configuratiewijziging noemde die gerelateerd zou kunnen zijn.
Met al die context geladen, identificeerde Claude Code het probleem in ongeveer twee minuten: een connection pool-configuratie die geldig was in onze staging-omgeving maar time-outcascades veroorzaakte onder productiebelasting. De vermelding van de teamgenoot "begon na de deploy van dinsdag" was de sleutelcontext die Claude Code naar de juiste config-diff leidde.
Ik gebruik het ook voor het sturen van statusupdates. Wanneer een lange build- of refactorsessie is afgerond, laat ik Claude Code een samenvatting posten naar het relevante Slack-kanaal. Geen context switching, geen kopiëren-plakken, geen vergeten het team te updaten.
Een workflow die ik heb ontwikkeld: aan het begin van elke codeersessie haal ik de laatste berichten uit het Slack-kanaal van mijn project in de context van Claude Code. Dit geeft de AI bewustzijn van recente teambeslissingen, blokkades en prioriteiten. Het is alsof je Claude Code een standup-meeting geeft voordat het begint met werken.
De Cloud Code Guide Sub-Agent — je ingebouwde documentatiebrein
Er is nog één toevoeging die het vermelden waard is: de Cloud Code guide sub-agent. Dit is een interne, niet-bestandsgebaseerde agent die vragen beantwoordt over de Claude Code CLI, de Agent SDK en de Claude API zelf.
Zie het als een deskundige collega die elke pagina van Anthropic's documentatie heeft gelezen en vragen kan beantwoorden zonder dat je de terminal verlaat. Het gebruikt zoeken, web fetch en andere tools om antwoorden te vinden maar — en dit is belangrijk — het bewerkt of schrijft geen bestanden. Het is puur informatief.
Ik merk dat ik het het meest gebruik wanneer ik randgevallen tegenkom. "Kan de Agent SDK streaming tool use-responses aan?" In plaats van documentatie te doorzoeken, vraag ik het de guide sub-agent en krijg ik binnen seconden een antwoord met relevante context. Voor ontwikkelaars die diep in het Anthropic-ecosysteem zitten, is dit een aanzienlijke tijdsbesparing.
Alles instellen: mijn aanbevolen configuratie
Hier is precies hoe ik mijn omgeving heb geconfigureerd om al deze functies effectief te gebruiken. Dit kostte wat trial and error, dus laat me je het debuggen besparen.
Stap 1: Update Claude Code naar de nieuwste versie. Dit klinkt vanzelfsprekend, maar de functies vereisen de meest recente release. Controleer of je op de laatste build zit voordat je ontbrekende functies gaat troubleshooten.
Stap 2: Installeer de skill creator plugin. Ga naar het Claude Code plugins-tabblad, zoek de skill creator en installeer hem. Herstart Claude Code na installatie — de plugin wordt pas actief na een herstart. Ik miste dit de eerste keer en besteedde twintig minuten aan het afvragen waarom niets werkte.
Stap 3: Schakel Ultra Mode selectief in. Typ ultrathink in een willekeurige Claude Code-sessie om Ultra Mode te activeren. Mijn aanbeveling: gebruik het voor multi-bestandstaken en complex debuggen. Laat het niet permanent aan staan tenzij je tokenbudget royaal is. Ik heb een simpele mentale regel: als de taak drie of meer bestanden raakt, schakel ik Ultra Mode in.
Stap 4: Configureer Slack-integratie. Installeer de Slack-plugin vanuit het plugins-tabblad. Je moet deze autoriseren met je Slack-werkruimte. Eenmaal verbonden, test met een eenvoudige berichtzoekopdracht om te verifiëren dat de verbinding werkt. Ik moest één keer opnieuw autoriseren omdat mijn initiële OAuth-token beperkte scopes had.
Stap 5: Test voice mode-beschikbaarheid. Typ /voice in je Claude Code-sessie. Als het activeert, zit je in de 5% uitrol. Zo niet, dan krijg je een bericht dat het nog niet beschikbaar is voor je account. Geen workaround — het is een server-side vlag.
Stap 6: Voer je eerste evol-test uit. Kies een eenvoudige bestaande skill en genereer een evol-test ervoor. Dit maakt je vertrouwd met het benchmarkingoutputformaat — slagingspercentage, runtime, tokengebruik — voordat je het nodig hebt voor serieuze skilontwikkeling. Begin klein, begrijp de metrics en pas het dan toe op complexe skills.
Stap 7: Bouw /simplify in je workflow in. Na elke significante codewijziging, voer het simplify-commando uit vóór het committen. Het duurt seconden en vangt het soort low-level problemen op dat code reviews vervuilt. Ik heb een mentale checklist toegevoegd: code schrijven, tests draaien, /simplify uitvoeren, suggesties reviewen, committen.
Veelvoorkomende valkuil: als de Slack-plugin "connection refused"-fouten toont, controleer dan of je werkruimtebeheerder integraties van derden niet heeft beperkt. Dit overkwam mij bij een klantproject waar de werkruimte strikt app-goedkeuringsbeleid had.
Wat ik fout had over deze update — en wat de meeste mensen zullen missen
Ik wil eerlijk zijn over iets. Toen ik de functielijst voor het eerst zag, dacht ik dat Anthropic de klassieke techbedrijf-move maakte — een stel incrementele verbeteringen verschepen en het een grote update noemen. Ik had het mis, en dit is waarom mijn initiële inschatting de kern miste.
De individuele functies zijn solide maar niet baanbrekend op zichzelf. Voice mode? Cool maar niche. Slack-integratie? Nuttig maar niet revolutionair. Remote control? Handig.
De echte verschuiving is wat er gebeurt als je ze combineert.
Ik draai nu sessies waarin ik een complexe taak begin achter mijn bureau met Ultra Mode, deze monitor vanaf mijn telefoon tijdens een vergadering via remote control, reageer op verduidelijkingsvragen met voice mode op mijn wandeling terug, en dan Claude Code de resultaten laat posten in Slack voor mijn team — allemaal zonder mijn flow te onderbreken of context te verliezen.
Dat is geen incrementele verbetering. Dat is een fundamenteel andere relatie met de tool. Claude Code stopte met iets zijn waar ik ga zitten om te gebruiken. Het werd iets dat de hele dag naast me werkt, over apparaten heen, over communicatiekanalen heen.
De skill creator met evol-testen is de slapersfunctie die de meeste mensen zullen onderschatten. Op dit moment voelen "AI-skills" als prompt engineering met extra stappen. Maar zelfverbeterende skills die zichzelf benchmarken en zich aanpassen aan nieuwe modellen? Dat is infrastructuur. Dat is het soort dat zich opstapelt. Over zes maanden zullen de ontwikkelaars die investeerden in het bouwen van robuuste, geteste skills een significant voordeel hebben boven degenen die nog steeds eenmalige prompts schrijven.
Eén eerlijke zorg: het tokengebruik telt op. Ultra Mode, evol-tests en de API-skill tegelijkertijd draaien kan je budget snel opbranden. Ik heb sessies gehad die 10x mijn normale tokenconsumptie gebruikten. Anthropic moet werken aan meer transparantie — ik zou graag een realtime tokenbudget-dashboard willen in Claude Code. Op dit moment kom je er pas achteraf achter dat je te veel hebt uitgegeven.
De cijfers na één week
Hier is hoe mijn workflow eruitzag voor en na de update, gemeten over een typische werkweek:
Context switches naar browserdocumentatie: gedaald van ruwweg 40 per dag naar ongeveer 8. De Claude API-skill en guide sub-agent handelen het meeste af van wat ik vroeger handmatig opzocht.
Code review-iteraties vóór merge: gedaald van gemiddeld 3 rondes naar 1,5 ronde. Het simplify-commando vangt oppervlakkige problemen op voordat menselijke reviewers de code zien, zodat reviewdiscussies zich richten op architectuur en ontwerp in plaats van opmaak en duplicatie.
Tijd besteed aan het debuggen van skills: met ongeveer 70% verminderd. Moeilijk precies te meten, maar de evol-testing geeft me vertrouwenscijfers in plaats van onderbuikgevoelens. Ik weet wanneer een skill werkt en wanneer niet, wat de "is het kapot of test ik verkeerd?"-onzekerheid elimineert.
Teamcommunicatie-overhead: merkbaar lager. Slack-integratie betekent dat ik context en updates deel zonder de terminal te verlaten. Minder kopiëren-plakken, minder "laat me uitleggen wat deze output betekent"-berichten.
Tokenkosten: circa 180% gestegen ten opzichte van mijn baseline vóór de update. Dit is de afweging. Ik geef meer uit aan API-gebruik maar win uren handmatig werk terug. Voor mijn workflow is de berekening duidelijk in het voordeel. Jouw ervaring hangt af van je specifieke gebruikspatronen en budget.
De grootste verandering zit niet in een enkele metriek. Het is het gevoel van continuïteit. Voorheen betekende Claude Code gebruiken achter mijn terminal zitten, gefocust, één ding doen. Nu is het verweven met mijn hele werkdag. Die verschuiving is moeilijk te kwantificeren maar onmogelijk te negeren zodra je het ervaart.
Wat ik als eerste zou bouwen als ik vandaag begon
Als je me zes maanden geleden had verteld dat ik zelfbenchmarkende AI-skills zou bouwen, codeersessies zou besturen vanaf mijn telefoon en tegen mijn terminal zou praten — had ik gelachen. Maar hier ben ik, en dit is wat ik zou prioriteren als ik dit vers zou opzetten.
Begin met het simplify-commando. Geen configuratie, directe waarde, bouwt goede gewoonten op. Voer het uit na elke sessie gedurende een week en je stopt nooit meer.
Investeer vervolgens tijd in de skill creator. Bouw één echte skill — geen speelgoedvoorbeeld — en voer evol-tests erop uit. Begrijp de benchmarkingoutput. Deze investering levert samengestelde rendementen op naarmate je meer skills bouwt.
Verken dan Ultra Mode voor je meest complexe workflows. Gebruik het niet voor alles — gebruik het strategisch, en je zult precies zien wanneer het uitgebreide redeneerbudget een verschil maakt.
Al het andere — voice mode, remote control, Slack — voeg je toe naarmate ze relevant worden voor jouw specifieke workflow. Het zijn krachtige toevoegingen, maar de kernproductiviteitswinst komt van simplify, de skill creator en Ultra Mode.
De kloof tussen ontwikkelaars die Claude Code behandelen als een fancy autocomplete en zij die het behandelen als een autonome ontwikkelpartner staat op het punt aanzienlijk te verbreden. Deze update maakt heel duidelijk aan welke kant van die kloof Anthropic aan het bouwen is.
Dus hier is mijn vraag aan jou: wat is de eerste skill die je zou bouwen als je AI-agent zichzelf kon testen, benchmarken en verbeteren?
Laten we samenwerken
Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.
- Fiverr (custom builds & integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (enterprise-oplossingen): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
