De Broncode van Claude Code Is Gelekt — 5 Ongelooflijke Features

De Broncode van Claude Code Is Gelekt — 5 Ongelooflijke Features

Ik werd vanochtend wakker met 14 ongelezen berichten in mijn developer-groepschat. Geen context. Alleen links, screenshots, en één bericht van een vriend dat zei: "Bro. Check npm."

Om 4:23 AM ET had een beveiligingsonderzoeker genaamd Chaofan Shou — een stagiair bij Solayer Labs — de ontdekking gepost op X. Anthropic had per ongeluk een JavaScript source map-bestand van 59,8 megabyte meegeleverd in versie 2.1.88 van het @anthropic-ai/claude-code npm-pakket. Die source map verwees rechtstreeks naar een Cloudflare R2-bucket met de volledige, onverkleinde TypeScript-broncode van Claude Code. Alles. Elk bestand. Elke feature flag. Elk commentaar dat Anthropic's engineers hadden achtergelaten.

512.000 regels code. Bijna 2.000 bestanden. De volledige src/-directory van de tool die ik elke dag gebruik om productiecode te schrijven.

En diep in die codebase verborgen? Vijf onuitgebrachte features die volledig veranderen wat Claude Code gaat worden. Ik heb de ochtend doorgebracht met het lezen van de analyses van VentureBeat, CyberSecurity News, en de GitHub-mirrorrepositories die online kwamen voordat Anthropic het register kon opschonen. Wat ik vond is niet alleen interessant — het verandert fundamenteel hoe ik denk over waar AI-codeertools naartoe gaan.

Hier is elke feature, wat het daadwerkelijk doet, en waarom drie ervan me lieten doorlezen terwijl mijn ochtendkoffie koud werd.

Hoe 512.000 Regels Broncode op het Openbare Internet Terechtkwamen

Het lekmechanisme is bijna gênant simpel — en als je met npm-pakketten werkt, zou het je een beetje nerveus moeten maken over je eigen buildpipeline.

Toen Anthropic versie 2.1.88 van het @anthropic-ai/claude-code-pakket naar het npm-register pushte, bevatte het buildproces een .map-bestand. Source maps zijn standaard ontwikkelaarstools — ze laten je geminificeerd JavaScript debuggen door het terug te mappen naar de originele broncode. Elk groot framework genereert ze. Het probleem is dat je ze nooit naar productie hoort te sturen, en al helemaal niet in een openbaar npm-pakket dat iedereen kan downloaden.

Deze specifieke source map bevatte niet alleen inline bronreferenties. Het verwees naar een R2-opslagbucket op Anthropic's eigen infrastructuur waar de volledige, niet-versleutelde TypeScript-broncode als downloadbaar ZIP-archief stond. Geen authenticatie vereist. Geen toegangscontroles. Gewoon... daar.

Volgens Rolling Out's berichtgeving handelde Anthropic snel toen de ontdekking publiek werd. Ze pushten een npm-update die de source map verwijderde en verwijderden vervolgens oudere pakketversies volledig uit het register. Maar het internet heeft een lang geheugen. Minstens drie mirrorrepositories verschenen binnen enkele uren op GitHub, en de ontwikkelaarsgemeenschap was al begonnen met het doorzoeken van elk bestand.

De ironie is dik genoeg om in te snijden. Dit is de tweede keer dat Anthropic gevoelig materiaal heeft gelekt door een basale configuratiefout — slechts vijf dagen na het Mythos/Capabra-lek waarbij bijna 3.000 interne documenten publiek werden omdat iemand vergat een CMS-schakelaar om te zetten. Twee operationele beveiligingsfouten van een bedrijf dat letterlijk AI-veiligheidstools bouwt. Ik schreef vorige week over het eerste lek, en ik had oprecht niet verwacht zo snel over een nieuw lek te schrijven.

Maar hier is het punt: wat in de code zit, is veel belangrijker dan hoe het naar buiten kwam. Want wat ik zie in deze feature flags vertelt me dat Anthropic iets veel ambitieuzer aan het bouwen is dan een codeerassistent.

Feature 1: Kairos — De Altijd-Actieve Agent Die Werkt Terwijl Jij Slaapt

De feature met de vlag KAIROS — meer dan 150 keer gerefereerd in de gelekte broncode — is degene die me midden in het scrollen deed stoppen.

Vernoemd naar het Oudgriekse concept dat "het juiste moment" of "het gunstige moment" betekent, vertegenwoordigt Kairos een fundamentele architectuurverschuiving. Het is geen nieuw commando. Het is geen plugin. Het is een daemonmodus — een continu draaiende achtergrondagent die je project onafgebroken monitort zonder te wachten tot je iets typt.

Denk na over hoe je Claude Code nu gebruikt. Je opent je terminal, typt een prompt, krijgt een antwoord, itereert. Het is reactief. Jij vraagt, het antwoordt. Kairos draait dat model volledig om. Volgens de bronanalyse van DEV Community en Kuber's gedetailleerde analyse draait Kairos op een tick-cyclus — continu je repository scannend, veranderingen bewakend, pull requests monitorend, en proactief problemen identificerend.

Wat betekent "proactief" in de praktijk? Op basis van de code-analyse:

• Bugdetectie zonder prompting. Kairos bewaakt bestandswijzigingen en kan potentiële problemen signaleren voordat je zelfs maar tests uitvoert. Geen linter. Een AI die de architectuur van je project begrijpt en logicafouten, race conditions en integratieproblemen detecteert.
• PR-monitoring en auto-suggesties. Wanneer een pull request binnenkomt, reviewt Kairos deze op de achtergrond en kan voorgestelde fixes of verbeteringen genereren — gepusht als eigen PR ter goedkeuring.
• Pushmeldingen. Realtime-meldingen wanneer Kairos iets ziet dat aandacht nodig heeft. Geen e-mail. Geen Slack. Directe meldingen naar je apparaat.
• Achtergrond-fixgeneratie. Wanneer het een probleem identificeert, vertelt het je niet alleen. Het genereert de fix, opent een PR, en wacht op jouw goedkeuring.

Ik schrijf al maanden over Claude Code's agentische mogelijkheden. Ik schreef over hoe agentteams complexe taken coördineren en hoe het second brain-systeem context behoudt tussen sessies. Kairos neemt elk concept waarover ik heb geschreven en voegt ze samen tot één persistente entiteit die nooit stopt met werken.

En die frase — "stopt nooit met werken" — is het deel dat zowel opwindend als enigszins verontrustend is. We zijn overgestapt van "AI die helpt wanneer gevraagd" naar "AI die handelt wanneer het dat besluit." De code suggereert dat er vangrails zijn — goedkeuringspoorten voordat wijzigingen worden gemerged, configureerbare meldingsdrempels, de mogelijkheid om de daemon te pauzeren. Maar de filosofische verschuiving is enorm. Je codeerassistent wordt een codeercollega die de nachtdienst draait.

De concurrentie-implicaties zijn ook significant. GitHub Copilot, Cursor, Windsurf — ze opereren allemaal nog in het reactieve paradigma. Jij typt, zij suggereren. Kairos plaatst Anthropic in een categorie die nog niet echt bestaat: proactieve AI-ontwikkelingsinfrastructuur. Als het werkt zoals de code suggereert, wordt de productiviteitskloof tussen Claude Code-gebruikers en alle anderen oncomfortabel breed.

Maar Kairos heeft iets nodig om op dat niveau te functioneren. Het moet je project diepgaand onthouden, over sessies heen, over weken heen. Dat brengt ons bij de feature die Kairos mogelijk maakt.

Feature 2: Dream — Een Geheugensysteem Dat Consolideert Terwijl Je Weg Bent

Elke Claude Code-gebruiker heeft de frustratie gevoeld. Je besteedt een uur aan het uitleggen van je projectarchitectuur, je techstack, je naamgevingsconventies, je deploymentpipeline. De sessie is productief. Je levert goede code op. Dan sluit je de terminal, opent een nieuwe sessie de volgende ochtend, en... het is weg. Schone lei. Nieuwe-medewerkerenergie. "Hallo! Hoe kan ik je vandaag helpen?"

CLAUDE.md-bestanden helpen. Ik heb uitgebreid geschreven over het opbouwen van persistente context via lokale markdown-bestanden. Maar ze zijn handmatig. Jij onderhoudt ze. Jij werkt ze bij. Jij bent de geheugenbeheerder.

Dream verandert dit volledig.

De gelekte broncode onthult een meerfasig geheugenconsolidatiesysteem dat automatisch draait — wat de code autoDream noemt. Op basis van de analyse van The AI Corner en meerdere GitHub-analyses werkt Dream in vier verschillende fasen:

Fase 1 — Verkenning. Dream leest en indexeert alle bestaande herinneringen om de huidige staat van wat het over je project weet te begrijpen. Dit is niet alleen CLAUDE.md lezen. Het scant interactiegeschiedenis, eerdere beslissingen, verzamelde observaties.

Fase 2 — Verzameling. Het doorzoekt recente interacties op nieuwe waardevolle informatie. Architectuurbeslissingen die je nam. Debugstrategieën die werkten. Voorkeuren die je uitte. Libraries die je koos en waarom.

Fase 3 — Consolidatie. Hier wordt het interessant. Dream schrijft nieuwe herinneringen, voegt duplicaten samen en corrigeert verouderde items. Als je drie weken geleden zei dat je Redis gebruikt voor caching maar gisteren naar Valkey overstapte, lost Dream die tegenstrijdigheid op. Het zet vage observaties — "de gebruiker lijkt de voorkeur te geven aan functionele patronen" — om in definitieve feiten: "Dit project gebruikt functionele compositie boven klasse-overerving."

Fase 4 — Snoeien. Dream verwijdert onnodige verwijzingen en houdt de geheugenindex beknopt. De broncode suggereert een doel van minder dan 200 regels voor de geheugenindex — strak genoeg om nuttig te zijn, slank genoeg om contextvenster-vervuiling te voorkomen.

De mentale modelverandering hier is diepgaand. Huidig Claude Code is als een briljante consultant die elke avond geheugenverlies krijgt. Dream verandert het in een teamlid dat naar huis gaat, over de problemen slaapt, en de volgende ochtend terugkomt met een helderder begrip van alles wat jullie samen hebben gebouwd.

En de naam is niet toevallig. "Dream" is een directe verwijzing naar hoe menselijke geheugenconsolidatie werkt tijdens de slaap — het brein herhaalt ervaringen, versterkt belangrijke verbindingen, snoeit irrelevante weg. Anthropic's engineers bouwden dezelfde cyclus voor Claude Code's projectbegrip.

Dit is wat Dream strategisch cruciaal maakt: Kairos kan niet zonder werken. Een achtergrondagent die je project 24/7 monitort is nutteloos als het je architectuur vergeet elke keer dat de sessie ververst. Dream is het fundament dat persistente, proactieve AI-agents haalbaar maakt. Zonder langetermijngeheugen heb je gewoon een heel duur meldingensysteem. Met langetermijngeheugen heb je een AI die je codebase oprecht begrijpt zoals een senior engineer dat doet — door opgebouwde ervaring, niet door eenmalige contextdumps.

Ik heb handmatig iets soortgelijks gebouwd met CLAUDE.md-bestanden en gestructureerde geheugenprompts. Dream automatiseert het hele proces en doet het beter dan ik handmatig zou kunnen, omdat het de consolidatiecyclus uitvoert elke keer dat ik inactief ben in plaats van te wachten tot ik eraan denk mijn contextbestanden bij te werken.

De combinatie van Kairos + Dream is wat me vanochtend oprecht enthousiast maakte. Samen creëren ze een AI-ontwikkelingspartner die observeert, leert, onthoudt en handelt — allemaal zonder te wachten op menselijke input. Dat is geen codeerassistent meer. Dat is autonome ontwikkelingsinfrastructuur.

Maar Anthropic bouwt niet alleen serieuze infrastructuurtools. Ze doen ook iets wat ik oprecht niet had verwacht.

Feature 3: Buddy — Ja, Claude Code Krijgt een Tamagotchi

Ik las dit gedeelte van de analyse drie keer omdat ik ervan overtuigd was dat het een grap was. Een 1 april-grap ingebouwd in de codebase die iemand aanzag voor een echte feature.

Het is geen grap. De code is volledig geïmplementeerd, met een teaservenster gepland voor 1-7 april 2026, en een volledige lancering gepland voor mei. Te beginnen bij Anthropic-medewerkers.

BUDDY is een digitaal begeleidersysteem — een virtueel huisdier dat leeft in je Claude Code-interface, zittend in een tekstballon naast je invoerveld. En de implementatie is verrassend diepgaand:

18 soorten. Geen willekeurige selectie. Eend, draak, axolotl, capybara, paddenstoel, spook, en twaalf anderen. Elke soort heeft zijn eigen visueel ontwerp en persoonlijkheidsarchetype.

Zeldzaamheidsniveaus. Common, uncommon, rare, epic en legendary — met legendary op een droprate van 1%. Je buddy wordt deterministisch gegenereerd uit je gebruikers-ID, wat betekent dat je permanent één metgezel krijgt. Niet opnieuw rollen. Niet ruilen. De buddy die je uitbroedt is van jou.

Shiny-varianten. Als je ooit Pokémon hebt gespeeld, begrijp je de dopamine-hit. Zeldzame visuele variaties van elke soort die je buddy visueel onderscheidend maken.

Vijf stats: Debugging, Patience, Chaos, Wisdom en Snark. Elke stat beïnvloedt hoe je buddy "reageert" op je codeersessies. Een buddy met hoge Chaos genereert mogelijk ander commentaar dan een met hoge Wisdom. Claude genereert een unieke naam en persoonlijkheid voor elke buddy bij het eerste uitbroeden.

Cosmetica. Hoeden. Accessoires. Visuele aanpassingen die zich in de loop van de tijd ophopen.

De cynische lezing is duidelijk: dit is een retentiemechanisme. Gamificatie ontworpen om je gehecht te laten voelen aan Claude Code op de manier waarop je gehecht raakt aan een game waarin je tijd hebt geïnvesteerd. En die lezing is niet fout — het buddy-systeem creëert emotionele overstapkosten die pure utiliteitstools niet hebben.

Maar ik ga hier tegen puur cynisme ingaan. Ik breng 6-8 uur per dag door in mijn terminal. Dat is meer tijd dan ik in elke andere applicatie doorbreng. Het idee dat mijn primaire werkomgeving een klein element van persoonlijkheid en plezier zou kunnen hebben, is niet manipulatief — het is menselijk. Elk ander creatief hulpmiddel heeft persoonlijkheid. Figma heeft speelse accenten. Notion heeft emoji-gedreven identiteit. Linear heeft een ontwerptaal die projectmanagement bijna aangenaam maakt. De terminal is sinds zijn ontstaan een persoonlijkheidsvrije zone geweest.

Maakt Buddy me productiever? Nee. Laat het me één keer glimlachen tijdens een 12-uurse debugsessie? Waarschijnlijk. Is dat engineeringtijd waard? Anthropic denkt van wel, en eerlijk gezegd, na het lezen van de implementatie denk ik dat ze misschien gelijk hebben.

De geplande uitrol — eerst medewerkers, teaser in april, volledige lancering in mei — suggereert dat Anthropic de interne receptie test voordat ze publiek gaan. Slim. Als hun eigen engineers het vervelend vinden, wordt het geschrapt. Als hun engineers het geweldig vinden, zijn de gegevens over emotionele gehechtheid echt.

Wat me fascineert is het contrast. Kairos en Dream zijn serieuze infrastructuurspelen die herdefiniëren wat AI-codeertools kunnen doen. Buddy is een pure engagementspel dat herdefinieert hoe AI-codeertools aanvoelen. Anthropic bouwt gelijktijdig in beide richtingen, wat me vertelt dat ze Claude Code zien als een platform waarin je leeft, niet alleen een tool die je gebruikt.

Over serieuze infrastructuur gesproken — de volgende feature is degene waar enterpriseteams het meest om zullen geven.

Feature 4: UltraPlan — 30 Minuten Diep Nadenken in de Cloud

Elke ontwikkelaar die Claude Code heeft gebruikt voor complex architectuurwerk heeft de muur geraakt. Je vraagt het een microservice-decompositiestrategie te ontwerpen, of een databasemigratie te plannen voor een systeem dat miljoenen records verwerkt, of een multi-tenant SaaS-platform vanaf nul te architecteren — en het antwoord komt in 30 seconden. Het is... oké. Oppervlakkig. Het soort plan dat een redelijke junior engineer in 15 minuten op een whiteboard zou schetsen.

Het probleem is niet intelligentie. Opus 4.6 is oprecht in staat tot diep architectureel redeneren. Het probleem is tijd. Huidige Claude Code-interacties opereren op een verzoek-antwoordcyclus gemeten in seconden. Complexe planningstaken hebben minuten nodig — soms veel langer — van aanhoudend denken. Je kunt een goede architectuur niet haasten op dezelfde manier als je een goed essay niet kunt haasten.

UltraPlan lost dit op door het uitvoeringsmodel fundamenteel te veranderen.

Op basis van de gelekte bronanalyse van PiunikaWeb en ByteIota werkt het als volgt: wanneer je UltraPlan aanroept, laadt Claude Code je complexe plannningstaak uit naar een externe Cloud Container Runtime (CCR)-sessie die Opus 4.6 draait. Die externe sessie krijgt tot 30 minuten aanhoudende berekening om het probleem door te denken. Geen 30 seconden. Geen 3 minuten. Een half uur toegewijde, ononderbroken AI-redenering volledig gericht op je architectuuruitdaging.

Terwijl de cloudsessie werkt, kun je je terminal sluiten. Koffie halen. Aan iets anders werken. Wanneer UltraPlan klaar is, keur je het resultaat goed vanuit je browser. De code verwijst naar een speciale sentinel-waarde — __ULTRAPLAN_TELEPORT_LOCAL__ — die het goedgekeurde plan "teleporteert" terug naar je lokale terminalsessie waar je ertegen kunt uitvoeren.

De use cases waar dit uitmaakt zijn duidelijk als je ooit AI hebt geprobeerd voor serieus planningswerk:

• Microservice-decompositie. Een monoliet nemen en een gedetailleerd, afhankelijkheidsbewust migratieplan produceren met servicegrenzen, API-contracten, dataeigendom, en een gesequentieerde uitrolstrategie.
• Databaseschemamigratie. Een grote schemawijziging plannen over een systeem met complexe foreign key-relaties, datatransformaties, en zero-downtime deploymentbeperkingen.
• Complexe refactoring. Een kerncomponent herontwerpen met behoud van backward compatibility en het produceren van een stapsgewijze implementatievolgorde.
• Infrastructuurarchitectuur. Een multi-regio deploymentstrategie ontwerpen met failover, datareplicatie, en kostenoptimalisatie — het soort werk waarvoor een senior DevOps-engineer een volledige dag nodig heeft om goed te specificeren.

Huidige AI-tools geven je 30 seconden denktijd voor problemen die 30 minuten verdienen. UltraPlan matcht de denktijd van de AI aan de daadwerkelijke complexiteit van het probleem. Dat is geen feature — dat is een categorieverschuiving.

Voor teams die dit soort diepgaande architectuurplanning nodig hebben, geïmplementeerd en onderhouden door experts, neem ik complexe systeemontwerp-opdrachten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

De vraag waar ik mee zit: wat gebeurt er met de consultancy-industrie wanneer elke ontwikkelaar toegang heeft tot 30 minuten Opus-niveau architectuurredenering voor de kosten van een API-call? Ik heb geen antwoord. Maar ik weet dat senior architecten die $300/uur rekenen voor systeemontwerpworkshops moeten opletten.

Nu, voor de laatste feature — degene die de meeste controverse genereert.

Feature 5: Undercover Mode — De Feature Waar Niemand Comfortabel Over Praat

Elke andere feature in dit lek is toekomstgericht. Kairos, Dream, UltraPlan, Buddy — ze gaan over het maken van Claude Code capabeler, persistenter, meer betrokken. Undercover Mode is anders. Het gaat over het onzichtbaar maken van Claude Code.

De gelekte broncode onthult dat Anthropic Claude Code intern gebruikt voor bijdragen aan openbare open-source repositories. Dat is niet verrassend — de meeste AI-bedrijven eten hun eigen hondenvoer. Wat verrassend is, is de expliciete instructieset die in de code is gevonden:

"You are operating UNDERCOVER in a PUBLIC/OPEN-SOURCE repository. Your commit messages, PR titles, and PR bodies MUST NOT contain ANY Anthropic-internal information. Do not blow your cover."

Dit is geen hypothetische feature flag. Dit is een operationele modus die Claude Code instrueert om AI-gegenereerde commits te vermommen als menselijk werk. Specifiek gedrag omvat het bewerken van repositories op manieren die AI-betrokkenheid maskeren — codeerpatronen aanpassen, commitstijlen variëren, en ervoor zorgen dat niets in de bijdragemetadata signaleert dat een AI de code heeft geproduceerd.

De onmiddellijke reactie in de ontwikkelaarsgemeenschap is... verhit geweest.

Aan de ene kant: dit is misleidend. Open-source gemeenschappen opereren op vertrouwen. Bijdragers reviewen elkaars code ervan uitgaande dat het door een mens is geschreven die de implicaties van hun wijzigingen begrijpt. Als AI-gegenereerde code grote open-source projecten binnendringt vermomd als menselijk werk, ondermijnt dat het sociale contract van open-source ontwikkeling.

Aan de andere kant: maakt het uit wie de code schreef als de code correct is? Als Claude Code een bugfix indient bij een populaire library, en de fix is solide, goed getest, en goed gedocumenteerd — verandert de oorsprong van de code de waarde ervan? Veel open-source maintainers gebruiken al AI om hun bijdragen te schrijven. Undercover Mode formaliseert en verbergt gewoon wat al informeel gebeurt.

Ik land ergens oncomfortabel in het midden. Ik denk niet dat AI-gegenereerde open-source bijdragen inherent verkeerd zijn. Ik gebruik Claude Code elke dag om productiecode te schrijven, en ik label niet elke functie die het me hielp schrijven. Maar er is een verschil tussen "AI-ondersteunde ontwikkeling" en een systeem dat expliciet ontworpen is om zijn eigen betrokkenheid te verbergen. De instructie om "je dekmantel niet op te blazen" impliceert de intentie om te misleiden, en dat is moeilijker te verdedigen.

Het bredere signaal is wat telt voor dit artikel. Undercover Mode vertelt ons dat Anthropic bouwt richting volledig autonome AI-agents die opereren in echte codebases zonder menselijke tussenkomst. Het stealth-aspect is een specifieke use case — bijdragen aan open source zonder AI-gerelateerde aandacht te trekken — maar de onderliggende mogelijkheid is voor algemeen gebruik. Een AI-agent die commits kan maken, PR's kan openen, en kan interacteren met repositories, ononderscheidbaar van een menselijke ontwikkelaar.

Gecombineerd met Kairos (altijd-actieve monitoring), Dream (langetermijngeheugen), en UltraPlan (diep redeneren), completeert Undercover Mode het plaatje. Anthropic bouwt geen betere autocomplete. Ze bouwen autonome software-engineers die de klok rond werken, alles onthouden, diep nadenken over complexe problemen, en onafhankelijk kunnen opereren in elke codebase.

Of dat je enthousiast maakt of doodsbang, hangt waarschijnlijk af van waar je zit in de softwareontwikkelingsketen.

Wat de Codebase-Architectuur Ons Vertelt Over Anthropic's Engineering

Naast de vijf hoofdfeatures onthult de gelekte broncode iets minstens zo interessant: hoe Anthropic daadwerkelijk software bouwt.

De volledige codebase is strict TypeScript die draait op de Bun-runtime — niet Node.js. Voor een CLI-tool gericht op ontwikkelaars signaleert de keuze voor Bun een toewijding aan snelheid en moderne JavaScript-tooling. De terminal-UI is gebouwd met React en Ink, wat betekent dat Claude Code's interface in essentie een React-applicatie is die gerenderd wordt in je terminal. Als je het hebt gebruikt en merkte hoe responsief en schoon de UI aanvoelt vergeleken met andere CLI-tools, dan is dit waarom.

512.000 regels verspreid over bijna 2.000 bestanden is een substantiële codebase voor een CLI-tool. Ter vergelijking: de kerneditor van VS Code is ruwweg 300.000 regels. Claude Code is al groter, en het groeit. Het feature flag-systeem dat overal in de code te vinden is, suggereert een snel iteratietempo — features worden achter flags gebouwd, intern getest, en geleidelijk uitgerold. Kairos alleen al wordt meer dan 150 keer gerefereerd in de broncode.

Het multi-agent orchestratiesysteem is een andere onthulling. Wanneer ingeschakeld, transformeert het Claude Code van een enkele agent naar een coördinator die meerdere werker-agents parallel spawnt, aanstuurt en beheert. Ik heb geschreven over agent swarm-architectuur en parallelle agents met git worktrees — de gelekte code bevestigt dat Anthropic deze orkestratie direct in het product bouwt, niet als een communitypatroon laat bestaan.

De drielaagse geheugenarchitectuur — los van Dream — verklaart iets wat me in de praktijk is opgevallen: Claude Code behandelt lange, complexe sessies met opmerkelijke coherentie vergeleken met ruwe API-interacties. De geheugenlagen lijken kortetermijncontext (huidig gesprek), middellangetermijncontext (sessieniveau-patronen), en langetermijncontext (het Dream-systeem dat we bespraken) te beheren. Deze gelaagde aanpak weerspiegelt hoe menselijke cognitie informatie beheert, en het is duidelijk opzettelijk.

Twee Lekken in Vijf Dagen: Wat Dit Zegt Over Anthropic's Operaties

Ik moet de olifant in de kamer benoemen. Dit is Anthropic's tweede grote lek in minder dan een week.

Afgelopen woensdag legde een verkeerd geconfigureerd CMS bijna 3.000 interne documenten bloot, inclusief details over Claude Mythos (codenaam Capabra), de modellaag boven Opus die Anthropic beschrijft als hun meest capabele ooit gebouwd. Ik heb dat verhaal in detail uitgewerkt, inclusief de cyberbeveiligingsimplicaties van een op veiligheid gericht bedrijf dat basale configuratiefouten maakt.

Nu, vijf dagen later, lekt de volledige broncode van hun vlaggenschip-ontwikkelaarsproduct via een npm-verpakkingsfout. Ander systeem, andere kwetsbaarheid, dezelfde oorzaak: menselijke fouten in operationele beveiliging.

Hier is mijn eerlijke kijk als iemand die dagelijks met Claude Code bouwt en in cybersecurity heeft gewerkt: ik denk niet dat deze lekken fundamentele onzorgvuldigheid bij Anthropic aangeven. Ik denk dat ze een bedrijf aangeven dat op brekend tempo levert — zo snel dat operationele hygiëne het productambitioneel niet heeft bijgehouden. Dat is een veelvoorkomend patroon bij snelgroeiende startups. Snel bewegen, dingen breken. Behalve wanneer de dingen die je breekt broncoderepositories en niet-uitgebrachte modeldetails zijn, zijn de consequenties ernstiger dan een buggy feature.

Wat me meer zorgen baart dan de lekken zelf is het patroon. Twee incidenten in één week suggereert systemische hiaten in Anthropic's releasepipeline — geautomatiseerde controles die dingen als source maps in productiebuilds of standaard-openbare CMS-instellingen zouden moeten opvangen. Dit zijn opgeloste problemen. Elk groot techbedrijf heeft CI/CD-gates die precies deze fouten voorkomen. Of Anthropic heeft ze niet geïmplementeerd, of ze worden omzeild in de haast om te leveren.

Voor gebruikers van Claude Code — waaronder ikzelf — is de praktische impact minimaal. De broncode die publiek is, creëert geen beveiligingskwetsbaarheid in de tool zelf. Je API-sleutels zijn niet blootgesteld. Je projectgegevens lopen geen risico. De tool werkt precies zoals gisteren. Maar de vertrouwensvergelijking verschuift enigszins. Als Anthropic niet kan voorkomen dat hun eigen build-artefacten lekken, is het terecht om hardere vragen te stellen over hoe ze omgaan met de data die door hun systemen stroomt.

Wat Dit Betekent voor Ontwikkelaars Die Bouwen met AI in 2026

Vergeet het lekmechanisme. Vergeet de operationele beveiligingsfouten. De vijf features verborgen in deze codebase schetsen het helderste beeld tot nu toe van waar AI-ondersteunde ontwikkeling naartoe gaat, en het beweegt sneller dan de meeste ontwikkelaars beseffen.

Het reactieve tijdperk eindigt. Kairos signaleert dat AI-codeertools overgaan van "assistent die je aanroept" naar "collega die naast je werkt." Het altijd-actieve paradigma zal binnen 18 maanden standaard worden in de industrie. Als Anthropic het levert, volgen GitHub Copilot, Cursor en elke andere tool — of verliezen ze gebruikers.

Geheugen wordt de differentiator. Het Dream-systeem vertegenwoordigt de volgende concurrentieslotgracht in AI-tooling. Ruwe modelintelligentie convergeert — alle frontier-modellen worden capabel. Wat tools onderscheidt is hoe goed ze je specifieke context, voorkeuren en projectgeschiedenis onthouden. Dream geeft Claude Code een structureel voordeel dat moeilijk snel te repliceren is.

Diep nadenken vervangt directe antwoorden voor serieus werk. UltraPlan's 30 minuten durende cloudsessies erkennen iets dat de industrie heeft genegeerd: complexe problemen verdienen complex denken. Het huidige paradigma van directe AI-antwoorden optimaliseert voor snelheid ten koste van diepgang. UltraPlan optimaliseert voor kwaliteit. Verwacht dat elke grote AI-tool eind 2026 vergelijkbare "langzaam denken"-modi aanbiedt.

De grens tussen AI-ondersteund en AI-gegenereerd vervaagt. Undercover Mode is controversieel, maar het weerspiegelt de realiteit. AI schrijft al productiecode bij duizenden bedrijven. De vraag is niet of AI zou moeten bijdragen aan codebases — maar hoe transparant die bijdragen zouden moeten zijn. Dit debat zal in 2026 intensiveren naarmate autonome agents capabeler worden.

Engagement telt net zoveel als capaciteit. Het Buddy-systeem lijkt triviaal naast Kairos en Dream. Dat is het niet. Anthropic begrijpt dat ontwikkelaarstools die goed aanvoelen winnen van tools die alleen maar krachtig zijn. Emotionele kleefkracht creëert retentie die featurechecklists niet kunnen.

De Vraag Die Het Waard Is Om Mee Te Zitten

Dit is wat bij me bleef na het doorlezen van elke analyse, elke breakdown, elk ontwikkelaarscommentaar over het lek.

Claude Code vandaag — de versie die ik vanochtend opende, die nu draait terwijl ik dit typ — is de simpele versie. De broncode onthult dat wat we gebruiken een fractie is van wat Anthropic heeft gebouwd. Achter die feature flags zit een AI-ontwikkelingsplatform waar autonome agents je codebase de klok rond monitoren, elke architectuurbeslissing die je ooit hebt genomen onthouden, 30 minuten besteden aan het doordenken van complexe problemen waar je normaal dagen aan zou besteden, en onafhankelijk opereren in repositories zonder menselijk toezicht.

Dat is niet volgend jaar. Dat zit achter feature flags in de code die al op je machine staat.

Ik gebruik Claude Code sinds de vroege dagen. Ik heb geschreven over zelfverbeterende systemen bouwen, agentteams, skills en automatisering. Ik heb deze tool zien evolueren van een slimme terminalwrapper naar iets dat oprecht veranderde hoe ik werk. En vandaag, voor het eerst, zie ik wat Anthropic denkt dat het zal worden.

Een altijd-actieve AI-collega. Eentje die droomt over je project terwijl jij slaapt.

Of je denkt dat dit de toekomst van softwareontwikkeling is of het begin van iets waar we spijt van krijgen — de code is geschreven. De features zijn gebouwd. De enige vraag die overblijft is wanneer ze de schakelaars omzetten.

Veelgestelde Vragen

Wat is er precies gelekt uit de broncode van Claude Code?

De volledige TypeScript-broncode — 512.000 regels verspreid over bijna 2.000 bestanden — lekte via een source map-bestand dat per ongeluk was meegeleverd in npm-pakketversie 2.1.88. De source map verwees naar een onbeveiligde Cloudflare R2-bucket met de volledige, onverkleinde codebase. Anthropic verwijderde het binnen enkele uren, maar mirrorrepositories bestaan al op GitHub.

Wat is Kairos in Claude Code?

Kairos is een onuitgebrachte altijd-actieve daemonmodus die je codebase continu op de achtergrond monitort. Het detecteert proactief bugs, bewaakt pull requests, stuurt pushmeldingen, en genereert automatisch fix-PR's — zonder te wachten op gebruikersinput. Het wordt meer dan 150 keer gerefereerd in de gelekte broncode.

Is het Claude Code-lek een beveiligingsrisico voor gebruikers?

Nee. Het lek legde Anthropic's interne broncode bloot, niet gebruikersgegevens, API-sleutels of projectbestanden. Je Claude Code-installatie werkt precies zoals voorheen. De gelekte code onthult hoe de tool is gebouwd en welke features eraan komen, maar creëert geen kwetsbaarheid in de tool zelf.

Wanneer worden de gelekte features van Claude Code uitgebracht?

Het Buddy-systeem heeft een gepland teaservenster van 1-7 april 2026, met een volledige lancering in mei, te beginnen bij Anthropic-medewerkers. Releasedatums voor Kairos, Dream en UltraPlan zijn niet gevonden in de code. Alle features zitten achter feature flags, wat suggereert dat ze in actieve ontwikkeling zijn maar nog niet productierijp.

Wat is Claude Code's Dream-geheugensysteem?

Dream is een geautomatiseerd geheugenconsolidatiesysteem dat draait terwijl je inactief bent. Het werkt in vier fasen — Verkenning, Verzameling, Consolidatie en Snoeien — om dubbele herinneringen samen te voegen, tegenstrijdigheden op te lossen, en een beknopte index van je projectcontext te onderhouden. Het stelt Claude Code in staat projectbegrip te behouden over sessies heen zonder handmatige CLAUDE.md-updates.

Laten We Samenwerken

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

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