Binnen de Echte Workflow-tools van het Claude Code Team

Vorige week stootte ik op iets dat mijn kijk op mijn eigen Claude Code-setup volledig veranderde.

Iemand had een overzicht samengesteld van de specifieke skills, plugins en interne tools die het Claude Code-ontwikkelteam dagelijks gebruikt. Niet de tools die ze op de markt brengen. Niet de functies in de changelog. De echte hulpmiddelen waarnaar de engineers bij Anthropic elke dag grijpen als ze Claude Code zelf bouwen.

Sommige zijn open-source. Sommige zitten verstopt achter interne CLI-vlaggen. Een paar ervan verklaren gedragingen die ik in Claude Code had opgemerkt maar waarvan ik het mechanisme nooit begreep. En één ervan — de Skillify-tool — deed me beseffen dat ik handmatig iets deed dat volledig geautomatiseerd kan worden.

Hier is wat me verraste: de kloof tussen wat het Claude Code-team intern gebruikt en wat de meeste ontwikkelaars in hun eigen setup hebben geconfigureerd, is enorm. Ik telde elf afzonderlijke tools in hun workflow. De gemiddelde Claude Code-gebruiker die ik heb gesproken, gebruikt er misschien twee of drie — en dat zijn meestal de voor de hand liggende.

Ik ga alle elf langslopen, laten zien welke je nu kunt pakken, en de interne tools markeren die je zelf kunt nabootsen met publieke sjablonen. Maar de echte waarde hier is niet de toollijst. Het is de workflowfilosofie achter hoe het team ze combineert — want dat is het deel dat je vandaag kunt stelen, ongeacht welke tools je installeert.

De Tool-stack waar Niemand over Praat

Voordat ik op elke tool inga, is dit het wat me het meest trof aan de setup van het Claude Code-team: ze behandelen Claude Code niet als een enkeldoelige codeerassistent. Ze hebben er een heel ecosysteem omheen gebouwd — codegeneratie, verificatie, vereenvoudiging, beveiligingsscanning, parallelle uitvoering, issue-triage en zelfs videoproductie. Allemaal via dezelfde interface.

De meesten van ons gebruiken Claude Code als een heel slimme pair programmer. Het Anthropic-team gebruikt het als een besturingssysteem voor softwareontwikkeling.

Dat onderscheid is belangrijk. Als je de volledige stack uitgestald ziet, begin je te begrijpen waarom hun outputsnelheid zo anders is dan wat de meeste ontwikkelaars bereiken met hetzelfde onderliggende model. Het gaat er niet om dat het model beter voor hen is. Het gaat om de toolinglaag die ze eromheen hebben gewrapped.

Hier is de volledige stack, opgedeeld in drie niveaus op basis van beschikbaarheid.

Tier Één — De Open-Source Tools die je Nu Kunt Installeren

Front-end Designs Plugin: Waarom hun UI-output er anders uitziet

Je hebt waarschijnlijk gemerkt dat sommige Claude Code-gebruikers UI-screenshots delen die er echt verzorgd uitzien — samenhangende typografie, doordachte spatiëring, kleurensystemen die echt werken — terwijl jouw outputs eruitzien als Bootstrap circa 2018. Het verschil is geen prompt engineering. Het is deze plugin.

De Front-end Designs plugin bevindt zich in Anthropic's officiële plugin-repository en verandert fundamenteel hoe Claude UI-generatie benadert. In plaats van de "veilige, generieke" output die de meeste AI-tools standaard produceren, past het designheuristieken toe die richting onderscheidende, productiewaardige interfaces sturen.

Ik installeerde het vanuit de marketplace met één commando:

claude plugins add marketplace front-end-designs

Na het herladen van mijn omgeving testte ik het met een eenvoudige prompt: "Bouw een dashboard voor een projectmanagementapp." Het verschil was onmiddellijk. De spatiëring voelde doelgericht. Het kleurenpalet was terughoudend — drie kleuren, consistent gebruikt. De typografie had hiërarchie. Het was geen Dribbble-shot, maar het was dichter bij iets wat een junior designer zou produceren dan de gebruikelijke AI-output.

De plugin werkt door ontwerpbewuste instructies te injecteren die Claudes neiging om "veilige" layouts te produceren, overschrijven. Het wordt aangeroepen via slash-commando's, zodat je het aan en uit kunt zetten afhankelijk van of je UI-werk of backend-logica doet.

Als je iets user-facing bouwt met Claude Code, zou dit je eerste installatie moeten zijn. Punt.

Code Simplifier Plugin: Het Lichtgewicht Opruimtool

Hier is een patroon waar ik maanden in verviel: een feature afmaken, committen, doorgaan. De code werkt, dus waarom aanraken? Omdat werkende code en schone code niet hetzelfde zijn, en zes weken later als ik die feature moet aanpassen, betaal ik de prijs voor elke snelkoppeling die ik nam.

De Code Simplifier is Anthropic's open-source versie van het interne opruimtool dat hun team aan het einde van codesessies uitvoert. Het spawnt een enkele agent die je recente wijzigingen scant, gedupliceerde logica, onnodige bestanden en te complexe implementaties identificeert, en deze vervolgens refactort terwijl de functionaliteit behouden blijft.

Wat maakt het anders dan gewoon Claude vragen om "deze code op te schonen"? Guardrails. De plugin heeft vaste beperkingen: prioriteer leesbaarheid boven slimheid, vermijd onnodige abstractie, bewaar bestaand gedrag. Het zal je architectuur niet willekeurig herstructureren omdat het denkt een beter idee te hebben. Het blijft in zijn lane — duplicatie verwijderen, naamgeving verduidelijken, controlestroom vereenvoudigen.

Ik voer het nu voor elke PR uit. Het vangt dingen die ik mis omdat ik te dicht op de code zit. Vorige week markeerde het drie hulpfuncties in verschillende bestanden die in wezen hetzelfde deden met iets andere handtekeningen. Samengevouwen tot één gedeelde functie. De agent deed er ongeveer 90 seconden over.

claude plugins add marketplace code-simplifier

Na installatie, roep het aan met /code-simplifier en laat het zijn ronde doen. Je krijgt een overzicht van aangebrachte wijzigingen, die je kunt bekijken voor het committen.

Commit PushPR Command: De Vervelende Onderdelen Automatiseren

Deze is bijna beschamend simpel, maar bespaart me minstens tien minuten per sessie. Het Commit PushPR commando automatiseert de commit-push-create-PR workflow in één actie.

Voor ik dit installeerde, was mijn einde-van-feature workflow: wijzigingen stagen, commit message schrijven, committen, pushen naar remote, browser openen, naar repo navigeren, PR aanmaken, beschrijving schrijven, reviewers toewijzen. Elke. Keer.

Nu is het één commando. Het verwerkt staged en unstaged wijzigingen, genereert een commit message op basis van de diff, pusht naar de remote en opent een PR met een automatisch gegenereerde beschrijving. Ik bekijk de PR-beschrijving nog steeds voor het indienen — ik ben geen monster — maar het raamwerk is afgehandeld.

Voor teams die meerdere agents parallel laten draaien (meer daarover zo), is dit nog waardevoller omdat elke agent zijn werk zelfstandig kan afsluiten zonder dat jij vijf verschillende PR-workflows handmatig beheert.

Tier Twee — Ingebouwde Functies die je Misschien Niet Kent

De Batch Skill: Waar Parallelle Uitvoering Serieus Wordt

Ik heb eerder geschreven over het parallel laten draaien van meerdere Claude Code-agents met Git worktrees. De Batch skill neemt dat concept en maakt er een eersteklas workflow van.

Hier is het verschil tussen wat ik handmatig deed en wat de Batch skill doet: ik maakte worktrees handmatig aan, spawnte agents handmatig, en mergte alles zelf. De Batch skill automatiseert de volledige pipeline — taakverdeling, worktree aanmaken, agent spawnen, uitvoering en merge-beheer.

De workflow ziet er zo uit:

Stap 1: Plannen. Je geeft het een brede taak — zeg, "Werk alle API-endpoints bij van v2 naar v3 in de codebase." De Batch skill gaat in planmodus en verdeelt dit in paralleliseerbare subtaken. Misschien identificeert het 8 endpointbestanden die onafhankelijk kunnen worden bijgewerkt.

Stap 2: Goedkeuring. Het presenteert het plan aan jou. Je bekijkt het, past het aan indien nodig, en keurt het goed. Deze stap is cruciaal — je wilt niet dat agents aannames maken over welke taken echt onafhankelijk zijn.

Stap 3: Uitvoering. Het maakt geïsoleerde worktrees voor elke subtaak en spawnt een agent in elk. Deze agents voeren simultaan uit zonder enige mogelijkheid om elkaar te hinderen. Die isolatie is het hele punt — geen merge-conflicten tijdens uitvoering, geen bestandsvergrendelingsproblemen, geen race conditions.

Stap 4: Merge. Zodra alle agents klaar zijn, beheert de Batch skill de merge terug naar de doelbranch en kan PRs aanmaken voor review.

De sleutelinzicht hier is dat dit niet gewoon Claudes native agent-parallellisme is met een mooie wrapper. Native parallelle agents delen dezelfde werkdirectory. De Batch skill geeft elke agent zijn eigen volledige kopie van de repository. Dat is een fundamenteel ander isolatiemodel, en dat is waarom migraties die riskant zouden zijn met gedeeld-toestand parallellisme, veilig worden met deze aanpak.

Ik gebruikte het vorige maand om de testsuite van een project te refactoren — 34 testbestanden bijwerken van een oude assertiebibliotheek naar een nieuwe. Zonder de Batch skill is dat een volledige middag van sequentiële updates. Met vijf agents deed de hele zaak er ongeveer twaalf minuten over. De merge was schoon.

Je triggert het met /batch gevolgd door je taakomschrijving. Geen installatie vereist — het is ingebouwd in Claude Code.

De Simplify Skill: De Grotere Broer van Code Simplifier

Als de Code Simplifier plugin een opruimploeg is, is de Simplify skill een volledig auditteam.

Het ingebouwde /simplify commando spawnt drie afzonderlijke agents — niet één — en evalueert je code tegelijk over meerdere kwaliteitsdimensies. Één agent richt zich op duplicatie en hergebruikmogelijkheden. Een andere evalueert complexiteit en leesbaarheid. De derde controleert op efficiëntieverbeteringen.

Waarom drie agents in plaats van één? Omdat een enkele agent die tegelijkertijd voor alle drie doelen optimaliseert, afwegingen maakt die niet altijd zichtbaar zijn. Duplicatie verminderen kan complexiteit verhogen. Efficiëntie verbeteren kan leesbaarheid schaden. Door de evaluatie te splitsen, kan elke agent pleiten voor zijn specifieke kwaliteitsdimensie, en de conflicten tussen hen maken afwegingen zichtbaar die je anders zou missen.

Ik testte dit tegen de Code Simplifier op dezelfde codebase. De Code Simplifier vond de voor de hand liggende dingen — gedupliceerde hulpfuncties, ongebruikte imports, te uitgebreide conditionals. De Simplify skill vond alles wat de Code Simplifier vond plus twee architecturale patronen die onnodige koppeling tussen modules creëerden. Eén ervan was een gedeeld toestandsobject dat drie componenten onafhankelijk aan het muteren waren — een bug die te gebeuren stond en die geen enkele linter zou vangen.

Wanneer gebruik je welke? Code Simplifier voor snelle opruim aan het einde van een sessie. Simplify voor diepgaande pre-merge reviews of wanneer je vermoedt dat je codebase structurele schuld heeft opgebouwd.

Claude Code Security Scan: De Kwetsbaarheidsjager

Deze ingebouwde functie krijgt lang niet genoeg aandacht. Anthropic lanceerde Claude Code Security als een mogelijkheid die codebases scant op beveiligingskwetsbaarheden en gerichte patches suggereert. Volgens de VentureBeat-berichtgeving vond het systeem tijdens de onderzoekspreview meer dan 500 kwetsbaarheden — en dit waren geen triviale bevindingen.

Wat maakt het anders dan traditionele statische analysetools zoals Snyk of SonarQube? Contextbewustzijn. Traditionele SAST-tools gebruiken patroonmatching — ze zoeken naar bekende kwetsbare patronen en markeren ze. Claude Code Security traceert datastromen over bestanden heen, begrijpt bedrijfslogica en identificeert complexe kwetsbaarheidpatronen met meerdere componenten.

De scan controleert op:

Invoervalidatiehiaten
Authenticatie- en autorisatiefouten
Problemen met geheimenbeheer (hardcoded credentials, blootgestelde API-sleutels)
Endpointblootstellingsrisico's
Injectiekwetsbaarheden (SQL, XSS, commandoinjectie)
Kapotte toegangscontrolepatronen

De functie die me het meest indruk maakte: adversariële zelfverificatie. Elke bevinding gaat door een tweede pas waarbij Claude in wezen argumenteert tegen zijn eigen resultaten voordat ze worden gepresenteerd. Het resultaat zijn minder valse positieven — wat, als je ooit een traditionele SAST-tool hebt gebruikt, je weet dat het zijn gewicht in goud waard is. Niets doodt een beveiligingsworkflow sneller dan een team dat bevindingen negeert omdat 80% ervan valse positieven zijn.

Elke bevinding komt met een aanbevolen patch, die je bekijkt en goedkeurt. Ik ben dit nu aan het begin van elke projectsprint aan het draaien in plaats van alleen vlak voor implementatie, en het heeft problemen gevangen die later aanzienlijk duurder te repareren zouden zijn geweest.

Remotion Skill: AI-aangedreven Video vanuit je Terminal

Deze verraste me het meest. Het Claude Code-team gebruikt een ingebouwde Remotion skill om motion graphics en marketingvideo's te maken — direct vanuit Claude Code. Niet vanuit een apart designtool. Niet vanuit After Effects. Vanuit dezelfde terminal waar ze code schrijven.

Remotion is een React-gebaseerd framework voor het programmatisch aanmaken van video's. In plaats van elementen op een tijdlijn te slepen, schrijf je React-componenten die renderen als videoframes. De Remotion skill van Claude Code leert het model precies hoe Remotion's API's werken — animatiepatronen, compositiestructuren, timingfuncties — zodat je een video kunt beschrijven en werkende code krijgt die het rendert.

Ik heb dit uitgebreid behandeld in mijn Remotion-videoworkflow post, maar de sleutelconclusie voor het gebruik door het Claude Code-team is dit: ze gebruiken het voor productaankondigingen, featuredemo's en marketingcontent. Het team dat de AI-tool bouwt, gebruikt de AI-tool om de AI-tool te vermarkten. Er zit een bevredigende recursie in.

Het praktische voordeel is echt echter. Een 30-seconden productaankondigingsvideo die een motiondesigner een volledige dag zou kosten, kan in minder dan een uur worden gegenereerd, geitereerd en gerenderd. En omdat het code is, is elk element parametrisch — verander de productnaam, wissel het kleurenschema, pas de timing aan, en je hebt een nieuwe video zonder opnieuw te beginnen.

Als je videocontent hebt willen maken maar geen After Effects-vaardigheden of budget voor een motiondesigner hebt, is dit de skill die het eerste de moeite waard is om mee te experimenteren.

Tier Drie — Interne Tools die je Kunt Nabootsen

Dit zijn de tools die het Claude Code-team intern gebruikt en die niet openbaar beschikbaar zijn. Maar hier is het ding — de patronen erachter zijn goed gedocumenteerd, en je kunt functionele equivalenten bouwen met het bestaande skillsysteem van Claude Code.

De Verify Skill: Geautomatiseerde Test-en-Fix Loops

De Verify skill is het antwoord van het Claude Code-team op een probleem dat elke developer kent: je maakt wijzigingen, je denkt dat ze correct zijn, je pusht ze, en CI faalt omdat een test die je niet had overwogen net is gebroken.

Verify automatiseert de loop. Het draait de testsuite van je project tegen je wijzigingen, identificeert fouten en probeert ze automatisch te repareren. Als de fix werkt, commit het het resultaat. Als het een fout niet kan repareren, presenteert het het probleem met context voor handmatige review.

De skill is projectspecifiek — het moet weten welk testframework je gebruikt, hoe je je tests uitvoert en wat als een geslaagde build telt. Het Claude Code-team heeft het geconfigureerd met hun interne testinfrastructuur en gebruikt zelfs de Claude Chrome-extensie voor visuele regressiecontroles.

Deze is verborgen achter interne CLI-vlaggen en is niet openbaar uitgebracht. Maar het patroon is eenvoudig na te bootsen. Je kunt een aangepaste skill bouwen die:

Je testsuite uitvoert (npm test, pytest, phpunit, wat je stack ook gebruikt)
Foutoutput parseert
Fouten terugstuur naar Claude met de relevante bronbestanden voor geautomatiseerde reparatiepogingen
Tests opnieuw uitvoert om de fix te verifiëren
Commit of escaleert op basis van resultaten

Ik heb een ruwe versie hiervan gebouwd voor mijn eigen Laravel-projecten met een aangepast SKILL.md bestand, en hoewel het niet zo gepolijst is als de interne versie, vangt het ongeveer 70% van de testfouten automatisch. De andere 30% vereist menselijk oordeel — wat precies is waar de tool correct escaleert.

Skillify: Claude Leren om naar je te Kijken als je Werkt

Dit is de tool die me mijn hele aanpak van skill-creatie liet herzien.

Skillify registreert een volledige workflowsessie — elk commando, elke beslissing, elke correctie — en converteert dit naar een herbruikbaar skillbestand. Het identificeert herhaalbare patronen, figureert uit welke tools en toestemmingen nodig zijn, stelt verduidelijkende vragen over edge cases en genereert een gedetailleerde gids die Claude autonoom kan volgen de volgende keer.

Denk na over wat dat betekent. In plaats van SKILL.md bestanden vanaf nul te schrijven (wat vereist dat je je impliciete workflowkennis expliciet articuleert — moeilijker dan het klinkt), doe je het werk gewoon eenmaal terwijl Skillify kijkt. Dan produceert het de skill.

Ik heb geen toegang tot de interne versie, maar het concept is reproduceerbaar. De skill-creator skill in Anthropic's publieke skills-repo brengt je een deel van de weg. Het zal je sessie niet automatisch opnemen, maar je kunt het een transcript van je workflowstappen geven en het genereert een gestructureerd skillbestand van die input.

De kloof tussen "handmatig een skill schrijven" en "Skillify er een laten genereren vanuit observatie" is de kloof tussen een proces documenteren en het proces dat zichzelf documenteert. Als Anthropic dit ooit open-sourceert, zal het een gamechanger zijn voor het skill-ecosysteem.

Tech Debt Skill: De Codebase Schoonmaker

Elk team heeft technische schuld. De meeste teams praten over het afbetalen "in de volgende sprint." Het Claude Code-team bouwde een skill die het daadwerkelijk doet.

De Tech Debt skill analyseert je codebase op gedupliceerde code, inconsistente patronen en logica die zou moeten worden geëxtraheerd naar gedeelde bibliotheken. Het gebruikt meerdere agents — één voor detectie, een andere voor refactoring — en vereist test- en linterverificatie na elke wijziging om ervoor te zorgen dat niets breekt.

De workflow die het team volgt is interessant: ze draaien de Tech Debt skill na elke codesessie, niet op geplande intervallen. Die aanpak van "continue opruiming" voorkomt dat schuld zich in de eerste plaats ophoopt. Het is het verschil tussen afwassen na elke maaltijd en ze een week laten opstapelen.

Je kunt dit vandaag benaderen door de Code Simplifier plugin te combineren met een aangepaste skill die je linter en testsuite uitvoert na elke vereenvoudigingspas. Het is niet zo geavanceerd als de interne multi-agent versie, maar het vangt het kerngedrag: detecteer duplicatie, refactor, verifieer dat niets brak.

Als je liever iemand deze setup van nul af laat bouwen, neem ik aangepaste Claude Code workflow-opdrachten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

DDUP: Detectie van Dubbele Issues

Als je een publieke repository beheert met een significant issuevolume, ken je de pijn: iemand dient een bugreport in, en het is identiek aan een issue dat drie weken geleden werd ingediend. Of het is 70% vergelijkbaar — vergelijkbaar genoeg om een duplicaat te zijn, maar anders genoeg dat een naïeve string-match het niet zal vangen.

DDUP gebruikt de GitHub CLI om nieuwe issues te scannen tegen bestaande, past een gelijkheidsdrempel toe (rond 70% zekerheid) en reageert op waarschijnlijke duplicaten met een uitleg van waarom het de match markeerde. Het vereist menselijke verificatie — het sluit niets automatisch — wat de juiste keuze is voor een tool die fuzzy beoordelingen maakt.

Het Claude Code-team gebruikt dit intern voor hun eigen issue-tracker. Voor open-source maintainers die verdrinken in dubbele issues, is dit patroon het bouwen waard. Je kunt een GitHub Action maken die wordt getriggerd bij het aanmaken van nieuwe issues, Claude gebruikt om het nieuwe issue te vergelijken met open issues, en een reactie post als het waarschijnlijke duplicaten vindt.

De Workflowfilosofie die er Meer toe doet dan Welk Individueel Tool dan ook

Hier is wat ik blijf terugkomen op na het bestuderen van deze tool-stack: de individuele tools zijn nuttig, maar het denken achter hoe ze worden gecombineerd is het echte inzicht.

Het Claude Code-team heeft een workflow gebouwd waarbij:

Elke codesessie eindigt met opruiming. Ze laten codekwaliteit niet degraderen en plannen dan een "refactoringssprint." De Code Simplifier of Simplify skill draait aan het einde van elke sessie, zoals tanden poetsen voor het slapengaan. Het is niet optioneel. Het is hygiëne.

Verificatie is geautomatiseerd, niet handmatig. De Verify skill betekent dat wijzigingen automatisch worden getest, niet wanneer iemand eraan denkt de testsuite te draaien. Dit verschuift het mentale model van het team van "Ik zou dit moeten testen" naar "testen gebeurt of ik er al dan niet over nadenk."

Parallelisatie is een eersteklas workflow, geen hack. De Batch skill met geïsoleerde worktrees betekent dat het team standaard parallelle uitvoering gebruikt voor elke taak die kan worden opgesplitst. Ze werken niet sequentieel en paralleliseren soms. Ze paralleliseren standaard en werken alleen sequentieel als taken echt van elkaar afhangen.

Beveiliging is geen fase — het is een continue controle. De ingebouwde beveiligingsscan draait gedurende de ontwikkeling, niet alleen voor implementatie. Kwetsbaarheden worden gevangen wanneer ze worden geïntroduceerd, niet nadat ze drie sprints in productie hebben gezeten.

Repetitieve workflows worden automatisch skills. Skillify betekent dat de institutionele kennis van het team niet gevangen zit in iemands hoofd of een wiki die niemand leest. Het is gecodeerd in herbruikbare skillbestanden die Claude autonoom kan uitvoeren.

Dit is het patroon dat het stelen waard is. Je hebt niet alle elf tools nodig om het voordeel te krijgen. Kies de filosofie die het meest resoneert met je huidige bottleneck en implementeer het met de tools die voor jou beschikbaar zijn.

Hoe je je Eigen Versie van deze Stack Bouwt

Als ik vandaag helemaal opnieuw zou beginnen, is dit de volgorde waarin ik deze tools zou installeren en configureren:

Week 1: De Fundering

Installeer de Code Simplifier plugin. Voer het aan het einde van elke codesessie uit. Bouw de gewoonte op voor je meer tools toevoegt.
Installeer Commit PushPR. Elimineer de frictie tussen "code is klaar" en "PR is open."

Week 2: Kwaliteitspoorten 3. Begin de ingebouwde /simplify opdracht te gebruiken voor pre-merge reviews. Vergelijk de output met de Code Simplifier om het verschil in diepte te begrijpen. 4. Voer de ingebouwde Security Scan uit op je hoofdproject. Repareer wat het vindt. Plan het als een wekelijkse controle.

Week 3: Parallelisatie 5. Probeer het /batch commando op een migratie- of refactoringtaak. Begin klein — misschien imports bijwerken in tien bestanden. Raak vertrouwd met de planning-goedkeuring-uitvoering-merge cyclus. 6. Als je dat nog niet hebt gedaan, lees mijn worktrees-gids om het isolatiemodel te begrijpen dat Batch veilig maakt.

Week 4: Aangepaste Skills 7. Bouw een Verify-stijl skill voor je specifieke testframework. Begin met de eenvoudigste versie: tests uitvoeren, fouten rapporteren, één fix proberen, opnieuw uitvoeren. 8. Documenteer je meest repetitieve workflow en gebruik de skill-creator om het te omzetten in een herbruikbaar skillbestand.

Aan het einde van een maand heb je een workflow die dichter bij wat het Claude Code-team draait lijkt dan wat 95% van de Claude Code-gebruikers heeft geconfigureerd. Niet omdat je hun interne tools hebt, maar omdat je hun workflowfilosofie hebt overgenomen: verificatie automatiseren, standaard paralleliseren, continu opruimen en kennis coderen in herbruikbare skills.

Wat dit ons Vertelt over de Richting van Claude Code

Het bestuderen van de interne tools die een team voor zichzelf bouwt, onthult meer over de toekomstige richting van het product dan welke roadmap-blogpost dan ook.

Het Claude Code-team investeert duidelijk zwaar in multi-agent orkestratie — niet alleen agents parallel laten draaien, maar ze coördineren naar complexe doelen met de juiste isolatie en merge-beheer. De Batch skill is de publiekgerichte versie hiervan, maar de interne Verify en Tech Debt skills laten zien hoe veel verder die orkestratie gaat.

Ze wedden ook zwaar op het skillecosysteem als de primaire uitbreidingslaag. Skillify — de mogelijkheid om workflows op te nemen en automatisch skills te genereren — suggereert dat ze willen dat het aanmaken van skills net zo eenvoudig is als het werk eenmaal doen. Als die visie slaagt, zal de marktplaats van skills exploderen omdat de drempel voor het aanmaken ervan daalt tot bijna nul.

En de integratie van de beveiligingsscan vertelt me iets over de competitieve positionering van Anthropic. Terwijl andere AI-codeertools racen om code sneller te genereren, bouwt Anthropic de guardrails in die AI-gegenereerde code veiliger maken. Dat is een gok op enterprise-adoptie, waar "snel maar riskant" verliest van "snel en geverifieerd" elke keer.

Voor degenen onder ons die dagelijks met Claude Code bouwen, is de conclusie eenvoudig: de tools zullen blijven verbeteren, maar de teams die er het meest van profiteren, zullen niet degenen zijn die wachten op het perfecte tool. Het zullen degenen zijn die nu de workflowfilosofie adopteren en de tooling upgraden als die aankomt.

De stack van het Claude Code-team is geen magie. Het is discipline — geautomatiseerde, geparalleliseerde, continu geverifieerde discipline. En dat deel is nu voor ons allemaal beschikbaar.

Veelgestelde Vragen

Welke Claude Code skills en plugins zijn gratis te gebruiken?

De Code Simplifier plugin, Front-end Designs plugin en Commit PushPR command zijn allemaal gratis en open-source uit Anthropic's officiële repository. Ingebouwde functies zoals /batch, /simplify en de Security Scan vereisen een Claude Code-abonnement maar geen extra kosten.

Hoe verschilt de Claude Code Batch skill van normale parallelle agents?

De Batch skill maakt geïsoleerde Git worktrees voor elke agent, waardoor elke subtaak zijn eigen volledige kopie van de repository krijgt. Normale parallelle agents delen dezelfde werkdirectory, wat risico op bestandsconflicten oplevert. Voor een diepere uitleg van worktree-isolatie, zie de parallelisatiesectie hierboven.

Kan ik mijn eigen versie van Anthropic's interne Verify skill bouwen?

Ja. Maak een aangepast SKILL.md bestand dat je testsuite uitvoert, fouten parseert, falende testcontext terugstuurt naar Claude voor reparatiepogingen, en tests opnieuw uitvoert om te verifiëren. Het patroon is eenvoudig — de interne versie heeft alleen strakker integratie met Anthropic's specifieke infrastructuur.

Waar controleert Claude Code Security Scan op?

Het scant op invoervalidatiehiaten, authenticatiefouten, hardcoded geheimen, endpointblootstelling, injectiekwetsbaarheden en kapotte toegangscontrole. In tegenstelling tot traditionele statische analyse, traceert het datastromen over bestanden heen en gebruikt adversariële zelfverificatie om valse positieven te verminderen.

Is de Remotion skill inbegrepen bij Claude Code?

Ja, de Remotion skill is geïntegreerd in Claude Code en wordt getriggerd wanneer je video- of motion graphics-aanmaak aanvraagt. Het vereist Node.js en een Remotion-projectsetup (npx create-video@latest), maar geen aparte plugin-installatie is nodig.

Laten we Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je tech-infrastructuur schalen? Ik help je graag.

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