De Claude desktop-app wordt een agentic OS

De Claude desktop-app wordt een agentic OS

De eerste keer dat ik een klantmap op het nieuwe Claude desktop-app icoon sleepte, deed ik wat elke engineer doet als iets werkt zoals het hoort: ik staarde ongeveer tien seconden naar het scherm, en zei toen hardop "wacht, is dat het?" tegen niemand, op een zaterdagochtend.

Ik verwachtte wrijving. Ik verwachtte een "richt je workspace in"-wizard. Ik verwachtte het gebruikelijke vijf-stappenritueel dat elke desktop-app je laat doorlopen voordat hij zich verwaardigt om echt werk te doen. In plaats daarvan landde de map gewoon. Claude indexeerde de structuur. De markdown-plansidebar vulde zichzelf met een conceptoverzicht van waar ik de avond ervoor mee bezig was — opgehaald uit het echte notitiebestand in de map. Een tweede sessie opende vanzelf in een zijpaneel, klaar voor een andere klant.

In de zestig seconden daarna sloot ik drie terminalvensters en een Cursor-tab.

Dat klinkt als een klein moment. Dat is het niet. Het afgelopen jaar was de Claude desktop-app de zwakke schakel in Anthropic's stack — een opgepoetste ChatGPT-kloon die in een aparte wereld leefde dan de agentic patronen die ik in de terminal van Claude Code draaide. Wilde je projecten, file context, parallelle workstreams of iets dat op een echt werkstation leek, dan ging je naar de CLI. De desktop-app was waar je een paragraaf plakte en een vraag stelde. Twee verschillende producten, twee verschillende mentale modellen, één logo.

Deze update dicht dat gat. De Claude desktop-app agentic OS-update brengt eindelijk het structured-filesystem-as-context patroon — hetzelfde patroon dat Claude Code als een senior engineer liet voelen in plaats van slimme autocomplete — naar de app die de meeste mensen daadwerkelijk de hele dag open hebben staan. En de tweede-orde-effecten op een multi-client workflow zijn groter dan de changelog suggereert.

Laat me je laten zien wat ik bedoel.

Wat "Agentic OS" eigenlijk betekent als je het niet meer als buzzword gebruikt

De helft van de AI-Twitter-tijdlijn gebruikt de term "agentic OS" om "de AI doet dingen" te bedoelen, wat onbruikbaar is. Hier is de werkdefinitie waar ik op uitkwam na een jaar bouwen binnen dit patroon: een agentic OS is een systeem waarin een gestructureerd filesystem de context, data, output en regels van je project bevat, en de AI die context dynamisch per sessie laadt. Het filesystem is het besturingssysteem. Het model is de runtime. Sessies zijn processen.

Dat is geen metafoor. Zo werkt Claude Code al maanden in de terminal: je doet cd naar een map, Claude leest CLAUDE.md, scant de structuur, pikt je skills-directory op, ziet wat er in de working tree staat, en begint te werken vanuit die context. Reset de sessie en hij laadt opnieuw. De map is het programma.

De desktop-app werkte tot vorige week absoluut niet zo. Hij werkte als een chatinterface. Elk gesprek was een eiland. Er was een Projects-feature, maar die was in essentie een map met opgeslagen chats en een system prompt — geen echte file context. Wilde je dat Claude de huisstijl van je klant kende, je mappenstructuur, en de drie referentiedocumenten die definiëren hoe je design reviews doet, dan plakte je ze in de chat. Elke keer. In elke sessie. Het was het patroon van 2023 verpakt in een wrapper van 2026.

De update voegt geen nieuwe functie toe. Hij verandert wat de app is. De desktop-app is nu een workspace gebouwd rond mappen, niet rond threads. Je wijst hem aan op een directory — een klantmap, een projectroot, een onderzoeksworkspace — en elke sessie die je binnen die directory opent, erft de file context, de markdown-notities, de structuur, en eventuele plannen die daar leven. Het is het agentic OS-patroon, eindelijk native in de app die de meeste gebruikers bereid zijn te openen.

Dat is de kop. Nu wil ik ingaan op wat dat in de praktijk daadwerkelijk verandert.

De vijf dingen die er echt toe doen (met bewijs)

Ik draai mijn echte klantwerk hier nu zo'n week in. Drie SaaS-klanten. Een merkidentiteitsrefresh. Een intern product dat ik bouw. Ik ga niet elk menu-item langslopen — Anthropic's release notes doen dat prima, en de officiële Claude Code desktop redesign post behandelt de developer-equivalenten in detail. Ik ga vijf gedragingen langslopen die hebben veranderd hoe ik daadwerkelijk werk.

1. Meerdere parallelle sessies die niet botsen

Ik draai vier sessies tegelijk terwijl ik dit schrijf. Twee voor één klant (één schrijft het implementatieplan voor een auth-refactor, één schrijft conceptrelease notes voor klanten voor hetzelfde project). Eén voor een andere klant met concurrentieonderzoek. Eén voor deze blogpost die je nu leest.

Elke sessie heeft zijn eigen scrollback, zijn eigen context, zijn eigen voortgang. Ze lekken niet in elkaar. Ik kan ertussen schakelen in de sidebar — net zoals je tussen tabs schakelt in een browser, behalve dat elke tab een actieve agent is die op de achtergrond echt werk doet. Als ik terugswitch, staat de sessie precies waar ik was, behalve dat hij soms drie stappen verder is omdat Claude doorging terwijl ik elders was.

Vóór deze update draaide ik parallelle sessies door terminalvensters te stapelen. Het werkte, maar het was lawaaierig. Vensterbeheer op een 14-inch laptopscherm is een belasting die ik elke context-switch betaalde. De native sidebar reduceert die belasting tot nul. Ik besefte niet hoeveel wrijving de multi-window dans toevoegde tot het ophield te bestaan.

Het niet voor de hand liggende voordeel: ik kan een langlopende taak in één sessie starten, naar een andere sessie springen, een gefocuste 20 minuten werk doen, en terugkomen. De eerste sessie is klaar. De tweede die ik startte zit middenin. Een derde die ik nog niet heb aangeraakt staat te wachten. Dit is hoe concurrency aanvoelt voor knowledge work, en de desktop-app heeft het uitgebracht voordat een van de IDE-plugins het deed.

2. Project-centrische workspace die je echte bestanden ziet

Kies een map. Niet "maak een project aan." Niet "configureer een workspace." Kies een map die je al op disk hebt — je klantmap, je code-repo, je onderzoeksnotities — en de app behandelt die als de werkcontext.

In de linker rail krijg je de boomstructuur. Mappen. Submappen. Outputbestanden. Markdown-notities. Wat er ook leeft. Klik op een bestand en het opent in het hoofdvenster. Bewerk een markdown-bestand en de wijzigingen worden teruggeschreven naar disk. Drop een nieuw bestand erin via Finder en de app ziet het binnen seconden. Er is geen upload. Er is geen sync. Er is geen "import." Het is je filesystem, zichtbaar gemaakt binnen de app waarmee je toch al chat.

Waarom dit ertoe doet: elke betekenisvolle workflow die ik draai heeft een map erachter. Mijn ColorPark merkbriefing-workflow heeft per klant een map — 00-brief.md, 01-mood.md, 02-tokens.md, 03-final-system.md. Mijn security-audit workflow heeft per opdracht een map met submappen voor findings/, evidence/, en report-drafts/. Mijn content workflow heeft, nou ja, wat je nu leest staat in content/mejba.me/.

Vóór de update vereiste het Claude laten "zien" van iets hiervan ofwel bestanden in de chat plakken, ofwel Claude Code in de terminal naast de desktop-app draaien, wat het hele punt van beide tegelijk hebben tenietdeed. Nu open ik de app, wijs naar de map, en Claude leest de structuur bij sessiestart. Wat direct leidt naar het volgende gedrag.

3. Context-aware sessie-init die haalt wat relevant is

Start een nieuwe sessie binnen een map en Claude vraagt niet "wat wil je doen?" Hij vraagt iets meer in de trant van "waar werken we nu aan?" — omdat hij de directorystructuur al heeft gelezen, de markdown-notities heeft gescand, en een werkend gevoel heeft van de projectstand.

Ik testte dit met een klantmap die ik drie weken niet had aangeraakt. Nieuwe sessie. Claude opende met: "Lijkt erop dat je werkt aan de Q2 brand refresh — de laatste notitie in 01-mood.md ging over het ophalen van referentiebeelden van drie concurrentensites. Wil je daarvandaan verder of ergens anders beginnen?" Dat is geen magie. Het is het agentic OS-patroon dat doet wat het altijd al deed in de terminal — alleen toont het zich nu in een schone UI in plaats van een muur monospaced tekst.

De sessie-init haalt:

• De mappenstructuur (zodat hij weet wat er is)
• Eventuele markdown-planbestanden (zodat hij de bedoelde volgorde kent)
• Recent gewijzigde bestanden (zodat hij weet wat hot is)
• Een samenvatting van submap-inhoud (zodat hij niet hoeft te raden wat findings/ betekent)

Je kunt elk hiervan overschrijven met een system prompt of een project-level CLAUDE.md, maar de default is goed genoeg dat ik er voor de meeste mappen niet aan ben begonnen. De verstandige default is hier de onderbelichte feature. De meeste "AI workspace"-tools vereisen dat je je een weg configureert naar iets bruikbaars. Deze is bruikbaar uit de doos.

4. De markdown-plansidebar die mijn whiteboard verving

Dit is de feature waarvan ik niet wist dat ik hem nodig had en nu niet meer kan werken zonder.

Er is een sidebar — inklapbaar, vastgezet aan de rechterkant van de workspace — die elk planbestand rendert als live markdown. Headings worden inklapbare secties. Checklists zijn interactief. Codeblokken renderen met syntax highlighting. Interne links springen tussen secties. Het is een markdown-viewer, maar verbonden met de actieve sessie: als Claude het plan tijdens een sessie bijwerkt, werkt de sidebar zich op zijn plaats bij, en als ik de sidebar bewerk, wordt het onderliggende bestand op disk direct bijgewerkt.

Wat dit collapseert: de hele "plan op één plek, werk op een andere, kopiëren-en-plakken ertussen"-routine. Mijn oude workflow bestond uit een Notion-doc met het plan, een terminal met Claude Code die het plan uitvoert, en een derde venster voor output. Drie contexten. Drie plekken om te vergeten welke versie actueel was. Nu is het plan de sidebar, het werk is het hoofdvenster, en ze zijn hetzelfde bestand.

Ik schrijf al twee jaar plannen in markdown — deels omdat platte tekst elke tool overleeft die ik heb geprobeerd, deels omdat Claude markdown beter leest dan welk ander formaat ook. De sidebar behandelt markdown-plannen eindelijk zoals ze behandeld verdienen te worden: als levende documenten die de AI en ik samen bewerken, niet als statische input die ik in een chat plak.

Voor de multi-client workflow is dit de ontgrendeling. Elke klantmap heeft zijn eigen plan.md. Open de klant, de sidebar vult zich. De sessie kent het plan. Ik ken het plan. We kijken allemaal naar hetzelfde. De "waar waren we?" vraag verdwijnt.

5. Split view, meerdere vensters en echte schermruimte

Sleep een sessie vanuit de sidebar naar het hoofdvenster en hij splitst. Sleep nog één en hij splitst drievoudig. Pop een sessie naar zijn eigen venster en je kunt vier onafhankelijke vensters tegelijk laten draaien over twee monitoren. Pas hun grootte aan als echte vensters. Snap ze naar hoeken. Behandel ze als de werkstationtools die ze daadwerkelijk zijn.

Dit klinkt als een klein UI-dingetje. Dat is het niet. Het is het verschil tussen de app gebruiken als chattool en hem gebruiken als werkstation. Op mijn externe monitor heb ik nu: klant A's sessie fullscreen links, klant B's sessie split met zijn plan-sidebar rechts, en een derde zwevend venster met mijn persoonlijke project op het laptopscherm. Drie verschillende breinen. Eén verenigde app. Nul context-switch belasting.

Een klein detail dat me verraste: de vensters blijven bestaan na herstart. Sluit de app af, herstart, en je layout komt exact terug. Sessies staan er nog. Plannen zijn nog geladen. Het is het soort detail dat aangeeft dat het team dit heeft gebouwd voor mensen die de hele dag desktopsoftware gebruiken, niet alleen voor demovideo's.

Wil je dieper kijken naar hoe ik mijn parallelle agent-setup structureerde voordat deze update het native maakte, dan behandelt mijn analyse van parallelle agents draaien met Claude Code het git worktree-patroon dat dit in de terminal oploste. De desktop-app-versie is sneller op te zetten maar minder flexibel — beide hebben hun plek.

Waar het nog tekortschiet (en waarom VS Code nog niet dood is)

Ik zou je een slechte dienst bewijzen als ik je vertelde dat deze update klaar is. Dat is hij niet. Er zijn echte gaten, en een paar zijn van het soort dat je terug zal trekken naar je oude tools op het slechtst mogelijke moment.

PNG-output van skills rendert als code, niet als afbeeldingen. Ik gebruik de Excalidraw-skill regelmatig om snelle architectuurdiagrammen te genereren. In de terminalversie van Claude Code geeft de skill een PNG-bestand uit en elke redelijke bestandsviewer rendert het. In de desktop-app rendert de PNG-output als een base64 blob in de chat — ziet eruit als een muur van wartaal in plaats van een afbeelding. Klik door naar het bestand in de boomstructuur en het opent prima in de systeemviewer. Maar de inline preview is kapot voor PNG's. Anthropic heeft erkend dat dit een bekend probleem is en een fix komt eraan, maar voorlopig: als je workflow leunt op visuele output, plan dan om ze handmatig te openen in Preview.

Verborgen directories verschijnen niet in de boomstructuur. Alles met een leidende punt — .env, .claude/, .git/, de skills/-map als je hem als verborgen hebt geconfigureerd — is onzichtbaar in de bestandsbrowser van de desktop-app. Je kunt ze niet zien, niet openen, niet bewerken in de app. Voor mij is dit het grootste gat. Het meeste van mijn serieuze skill-werk gebeurt in .claude/skills/-directories, en die bestanden bewerken is een vast onderdeel van mijn dag. De desktop-app doet alsof ze niet bestaan. VS Code toont ze standaard.

Credential-bestanden zijn op zijn best alleen-lezen. Zelfs als een verborgen bestand niet verborgen was, heeft de desktop-app geen prettig patroon voor het bewerken van .env-bestanden of iets gevoeligs. Hij is niet ontworpen als code-editor voor ops-bestanden, en dat is in principe prima — maar het betekent wel dat elke workflow die "tweak de env, restart de agent, kijk wat er gebeurt" inhoudt, mij nog steeds vereist om alt-tab naar VS Code te doen. Dat is een workflow-naad die ik elke dag merk.

De geïntegreerde editor is goed, niet geweldig. Voor markdown is hij uitstekend. Voor de meeste configbestanden en kleine TypeScript- of Python-edits is hij prima. Voor alles wat Language Server-features nodig heeft — autocomplete, type hints, jump-to-definition, find-references — probeert hij niet eens te concurreren met een echte IDE. En dat hoeft hij ook niet. Maar dat betekent dat de desktop-app een workspace is, geen vervanging voor je editor. Je hebt nog steeds VS Code of Cursor open voor echt codewerk.

Dus zo verdeel ik mijn tijd nu: de Claude desktop-app is waar ik klantwerk draai, plannen schrijf, sessies beheer en meerdere projecten parallel levend houd. VS Code is waar ik verborgen bestanden bewerk, complexe code-refactors doe, en alles waar goede LSP-ondersteuning voor nodig is. Claude Code in de terminal is waar ik langlopende gescripte agent-workflows draai die helemaal geen UI nodig hebben. Drie tools, drie taken, één filesystem eronder. Het agentic OS-patroon werkt omdat alle drie dezelfde mappenstructuur en dezelfde planbestanden zien.

Als je een security- of compliance-workflow draait waarbij de zichtbaarheid van .env en verborgen configbestanden onbespreekbaar is, behandelt de Claude Code desktop security upgrade de afwegingen dieper. Andere doelgroepen, andere risicoprofielen.

Hoe ik het echt heb opgezet (de 12-minutenversie)

De snelste manier om hier waarde uit te halen, is stoppen met lezen en beginnen met opzetten. Hier is de exacte volgorde die ik op mijn eerste ochtend met de update doorliep. Het kostte twaalf minuten. Het verving ongeveer drie dagen aan opgehoopte workflowdrift.

Stap één — kies je top drie projectmappen. Niet allemaal. De drie die je echt elke dag aanraakt. Voor mij: mijn agency-klantmap, mijn persoonlijke blog-contentmap, en het build-in-public project dat ik 's avonds verstuur. Drie, niet meer.

Stap twee — open de app en sleep de eerste map naar de workspace. De app vraagt je om te bevestigen als projectworkspace. Bevestig. De boomstructuur vult zich in de linker rail. Configureer nog niets. Kijk er gewoon naar. Merk op wat er is. Merk op wat er ontbreekt.

Stap drie — schrijf een paragraaf-lange project.md in de root als die er nog niet is. Drie of vier zinnen die uitleggen wat dit project is, voor wie het is, en in welke staat het is. Dit is het hoogste-leverage ding dat je kunt doen. De sessie-init leest het bij elke nieuwe sessie en zet de context perfect. Ik houd de mijne onder 200 woorden. Alles langer wordt genegeerd.

Stap vier — maak of open plan.md en pin hem aan de markdown-sidebar. Heb je een bestaand plan in welk formaat dan ook, plak het erin en laat Claude de markdown-structuur opschonen in een verse sessie. Heb je er geen, vraag Claude er een te schetsen op basis van wat in de map staat. Het plan klopt niet bij de eerste ronde. Dat geeft niet. Je itereert het twee keer en het klopt.

Stap vijf — start drie sessies in dezelfde workspace. Eén voor "huidige taak," één voor "research," één voor "review." Denk niet te diep na over de namen. Het punt is om het parallelle sessiemodel te voelen. Draai ze tegelijk. Schakel ertussen. Merk op dat geen van hen context verliest.

Stap zes — herhaal stap twee tot en met vijf voor de andere twee mappen. Aan het eind heb je drie workspaces, drie planbestanden, en ergens tussen zes en negen actieve sessies. Dat is je nieuwe basislijn.

Stap zeven — sluit elk ander AI-tabblad en venster voor een dag. Dit is optioneel maar ik raad het aan. De eerste dag dat ik mezelf dwong volledig in de desktop-app te leven, leerde ik meer over zijn limieten en sterktes dan ik in een week half-gebruiken zou hebben geleerd.

Wil je een dieper architecturaal perspectief op hoe je die mappen structureert voor maximale agent-leverage, dan behandelt mijn doorloop van het Claude Code agentic OS framework het patroon in detail — dezelfde principes, toegepast op de terminal-first versie van de workflow.

Wat dit betekent voor multi-client werk

Ik draai meer dan één ding tegelijk. De meeste mensen die dit lezen ook. De eerlijke test van elke "workspace"-tool is niet hoe hij één project afhandelt — het is hoe hij vijf afhandelt.

Vóór deze update had mijn multi-client workflow een specifieke vorm. Elke klant leefde in zijn eigen map op disk. Elke had een Notion-pagina of een lokaal markdown-bestand met het plan. Elke had zijn eigen Claude Code terminalsessie, soms twee. Om ertussen te schakelen, deed ik cd naar de nieuwe map, herstartte de Claude Code-sessie, plakte de relevante context erin, en begon te werken. De switch kostte me ongeveer drie tot vijf minuten wrijving — niet omdat de tools traag waren, maar omdat de her-grounding traag was. Ik moest mezelf herinneren waar het project van deze klant was, in welke staat het was, wat de volgende zet was.

De desktop-app reduceert die her-grounding tot ongeveer zes seconden. Klik op de workspace. Het plan laadt in de sidebar. De meest recente sessie laat zien waar ik gebleven was. De boomstructuur herinnert me aan wat er is. Ik werk weer voordat ik de slok koffie heb afgemaakt die ik begon tijdens het schakelen. Vermenigvuldigd over vier of vijf klantswitches per dag is dat ergens rond de 15 tot 20 minuten wrijving die gewoon verdwenen zijn. Over een week is dat een echt stuk teruggewonnen focus.

Combineer dat met het parallelle sessiemodel en de wiskunde wordt nog vreemder. Ik kan een langlopende taak in klant A's workspace laten draaien terwijl ik actief in klant B's workspace schrijf. De agent doet zijn werk op de achtergrond. Ik check hem als ik terugswitch. Het "Claude is bezig, ik moet wachten"-patroon is verdwenen voor elk werk dat geen directe input van mij vereist.

Dit is het deel waarvan ik wil dat je er even bij stilstaat: de productiviteitswinst zijn niet de parallelle sessies zelf. Het is de eliminatie van de kosten van het draaien van parallelle sessies. Je kon altijd al meerdere Claude Code-instanties draaien. Je betaalde er alleen voor in terminal-window-management overhead en context-switch belasting. Native parallelle sessies maken Claude niet sneller. Ze maken mij sneller, door de belasting weg te nemen.

Heb je liever dat iemand dit soort multi-client agentic setup voor je bouwt in plaats van het zelf vanaf nul uit te zoeken, dan neem ik workflow-architectuuropdrachten aan via Fiverr — je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD. Voor solo-operators brengt de twaalf-minuten setup hierboven je echter het grootste deel van de weg op eigen kracht.

Het verrassende tweede-orde-effect: ik sloot VS Code vaker dan verwacht

Hier is het resultaat dat ik niet had voorspeld.

Ik begon de week in de veronderstelling dat de desktop-app mijn chattool zou vervangen maar mijn code-editor onaangeroerd zou laten. Tegen woensdag greep ik misschien een derde zo vaak naar VS Code als de week ervoor. Niet omdat de editor van de desktop-app beter is dan VS Code — dat is hij niet, en dat zei ik hierboven — maar omdat het meeste van wat ik in VS Code deed eigenlijk geen code-editing was. Het was bestanden lezen. Markdown-notities kruisreferentiëren. Configdocs bewerken. Diffs reviewen. De desktop-app handelt al die dingen goed genoeg af dat de wrijving van een aparte IDE openen het niet waard was voor een vijfregelige markdown-edit.

VS Code is nu wat hij van begin af aan had moeten zijn: mijn deep-code-work tool. Als ik een TypeScript-module moet refactoren over zes bestanden met goede typecheck, ben ik daar. Als ik een complexe regex moet schrijven met een echte linter, ben ik daar. Als ik iets moet debuggen met breakpoints, uiteraard, ben ik daar. Maar voor de tientallen kleine bestandsedits die een werkdag vullen — pas dit markdown-plan aan, update die env-notitie, tweak dit promptbestand — is de desktop-app nu dichterbij en minstens zo snel.

De eerlijke samenvatting: de Claude desktop-app verving geen van mijn tools. Hij absorbeerde de makkelijke delen van drie ervan — chat, file viewing, lichte editing — en liet me alleen voor de zware tools grijpen als ik ze echt nodig had. Dat is een stillere soort upgrade dan "X is dood, lang leve Y," maar het is het soort dat daadwerkelijk samengesteld effect heeft.

Waar ik op let

Een paar dingen waar ik op let terwijl de ruwe randjes worden bijgevijld.

De PNG-renderingfix staat boven aan mijn lijst. Het skills-ecosysteem leunt zwaar op visuele output — Excalidraw, Mermaid, Figma-exports — en een agentic OS dat zijn eigen visuele artefacten niet inline kan renderen, mist een laag verfijning. Zodra dat uitkomt, wordt de desktop-app de voor de hand liggende default voor elke visueel-zware workflow.

Zichtbaarheid van verborgen bestanden is de moeilijkere. Er is een echte spanning tussen "dit is een schone workspace voor niet-developers" en "ik moet .claude/skills/ bewerken zonder de app te verlaten." Mijn gok is dat Anthropic binnen een kwartaal een power-user toggle uitbrengt — toon verborgen bestanden, bewerk env-bestanden, het hele gedoe. Doen ze dat niet, dan blijft het gat tussen de desktop-app en een echte IDE breder dan nodig.

De grotere vraag, waar ik nog geen antwoord op heb: gaat de desktop-app features absorberen die in de browser-gebaseerde Claude-ervaring leefden? Projects, artifacts, computer use, het hele Co-work patroon? Mijn gok is ja, en ik denk dat de komende zes maanden zullen laten zien dat de desktop-app de canonieke surface wordt voor serieus Claude-gebruik, met de browser-app gereduceerd tot een snel-vraag-tool. Het agentic OS-patroon past niet echt in een browsertabblad. Het past in een werkstation.

Wil je een primer over hoe het bredere desktop-automation verhaal zich heeft afgespeeld — Claude Co-work, Dispatch, de remote-agent stack — dan behandelde ik de Claude Co-work desktop automation experience in detail toen die features net landden. De desktop-app-update is het volgende hoofdstuk van datzelfde verhaal.

De vraag die de moeite waard is om bij stil te staan

Het ding waar ik steeds op terugkom is dit: het afgelopen decennium heeft elke productiviteitsapp om dezelfde vierkante centimeter aandacht gevochten. Notion versus Obsidian versus Roam versus Apple Notes. VS Code versus JetBrains versus Sublime. ChatGPT versus Claude versus Gemini. Tabbeheer. Vensterswitchen. Het constante laaggespannen gezoem van "waar heb ik dat ook alweer neergezet."

Wat het agentic OS-patroon stilletjes doet, is het filesystem weer de bron van waarheid maken. Je mappen zijn je projecten. Je markdown is je plan. Je AI is je runtime. De tool die je gebruikt om met alle drie te interacteren is uitwisselbaar — terminal vandaag, desktop-app morgen, wie weet wat volgend jaar — omdat het substraat eronder gewoon bestanden zijn. Bestanden die op elk besturingssysteem hebben gestaan sinds 1969. Bestanden die elke "workspace"-tool zullen overleven waar ik ooit voor heb betaald.

De Claude desktop-app voegde deze update geen features toe. Hij sloot zich aan bij een patroon. En als je een week binnen het patroon hebt gewerkt, voelt teruggaan naar chat-as-an-island als teruggaan naar e-mails schrijven in Notepad na het gebruik van Gmail.

Dus hier is de vraag die ik je wil meegeven, degene die de hele week door mijn hoofd rolde: als het substraat onder je werk gewoon bestanden zijn, en de AI-runtime kan onmiddellijk in elk van die bestanden plug-and-playen, wat is er dan eigenlijk nog onderscheidend aan de apps waar je voor hebt betaald? Mijn korte antwoord: minder dan ik dacht. Mijn langere antwoord is waar de komende zes maanden van deze blog over zullen gaan.

Voor vanavond ga ik elk tabblad sluiten dat ik niet gebruik, mijn volgende klantmap op de desktop-app droppen, en kijken hoe ver ik hem kan duwen voordat er iets breekt. Heb je gewacht op toestemming om hetzelfde te doen, dan is dit het.

Veelgestelde vragen

Is de Claude desktop-app hetzelfde als de desktop redesign van Claude Code?

Nee — ze zijn gerelateerd maar verschillend. De Claude Code desktop redesign (14 april 2026) richt zich op developers met een geïntegreerde terminal, diff viewer en parallelle codingsessies. De Claude desktop-app agentic OS-update brengt map-gebaseerde projectworkspaces, markdown-plansidebars en parallelle sessies naar de algemeen-bedoelde chat-app. Zelfde familie, andere doelgroepen. Zie de sectie hierboven voor de split-view setup die ik over beide gebruik.

Vervangt de nieuwe desktop-app VS Code of Cursor?

Voor lichte file-editing, planbeheer en multi-client workflow-orchestratie, ja — ik grijp ongeveer een derde zo vaak naar VS Code als voorheen. Voor diep codewerk dat LSP-features, debugging of het bewerken van verborgen bestanden (.env, .claude/) vereist, nee. Het eerlijke patroon is om de Claude desktop-app als je workspace te gebruiken en je IDE als je code-deep-work tool.

Wat is er kapot in de huidige Claude desktop-app update?

Drie bekende gaten: PNG-output van skills rendert als codeblokken in plaats van afbeeldingen (fix verwacht), verborgen directories zoals .claude/ en .env zijn onzichtbaar in de boomstructuur, en de geïntegreerde editor mist Language Server-features. Geen ervan zijn dealbreakers voor de meeste workflows, maar plan eromheen als je werk afhangt van visuele output of verborgen configbestanden.

Hoe stel ik parallelle sessies in in de Claude desktop-app?

Sleep een map naar de app om een workspace te maken, open dan meerdere sessies binnen die workspace vanuit de sidebar. Elke sessie heeft onafhankelijke context. Sleep sessies naar het hoofdvenster om ze in split-view te zetten, of pop ze naar aparte vensters voor multi-monitor setups. Layouts blijven bestaan na herstart. De volledige twaalf-minuten setup-walkthrough staat in de sectie hierboven.

Kan ik markdown-plannen bewerken binnen de desktop-app?

Ja — pin elk markdown-bestand aan de rechter plan-sidebar en het rendert als live, bewerkbare markdown. Edits worden direct teruggeschreven naar disk. Als Claude het plan tijdens een sessie bijwerkt, weerspiegelt de sidebar de wijziging op zijn plaats. Dit is de ene feature die mijn Notion-plus-terminal workflow het schoonst verving.

Laten we samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je tech-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 (security services): xcybersecurity.io