Een AI tweede brein met Claude Code en Obsidian

Ik heb een tweede brein gebouwd, en ik gebruik het de hele dag. Mijn geheugen zit niet meer alleen in mijn hoofd, maar in een systeem dat onthoudt en meewerkt, voor mijn werk én daarbuiten.

In dit stuk laat ik zien hoe ik het bouwde, wat het dagelijks voor me doet, en hoe je er zelf een opzet. Noem het AI in Obsidian, een tweede brein of een doorzoekbare notitie-app met een AI-assistent erop: het komt op hetzelfde neer. Geen theorie uit een whitepaper, gewoon mijn eigen opstelling.

Dat systeem bestaat uit twee delen. Het eerste is Obsidian, een app waarin je je notities als platte tekst bewaart. Mijn hele verzameling notities (in Obsidian heet dat een vault) is het geheugen: elke klantnotitie, elk gespreksverslag, elk idee en elke beslissing staat erin, doorzoekbaar. Het tweede is Claude Code, de AI-assistent van Anthropic die op mijn eigen computer draait. Dat zijn de handen: het leest die vault, schrijft erin en voert er werk mee uit. Geen los chatvenster dat morgen vergeten is wat we vandaag bespraken, maar een agent met permanent geheugen.

Voor mij is dat geen luxe. Ik werk alleen, dus er is niemand in de kamer die zegt: maak dit eerst af, daar zul je jezelf later dankbaar voor zijn. Dus bouwde ik die stem zelf. Ik heb ADHD: zonder een systeem dat vasthoudt wat ik loslaat, valt de helft op de grond. Het tweede brein is die partner. Het vangt mijn losse ideeën op zodat ze niet verdwijnen, en het houdt me bij wat ik met een heldere kop had gepland. Vertrouw op de ik van gisteren.

Het gat dat niemand benoemt: geheugen

De meeste mensen gebruiken AI als een gokautomaat. Een losse prompt, een los antwoord, en morgen begin je weer bij nul. Het echte probleem met tools als ChatGPT is niet de intelligentie, maar het gebrek aan geheugen: de context vervalt zodra je het tabblad sluit.

Daar heb je geen ingewikkelde technische opstelling voor nodig (developers noemen dat RAG). Een vault die de agent kan lezen en beschrijven is genoeg. Obsidian is platte tekst, lokaal, van mij. Niet opgesloten in het geheugen van één leverancier. Komt er volgend jaar een beter model langs, dan verhuist mijn brein gewoon mee.

Hier gaat niets verloren, en mijn AI kan er altijd bij.

Maar ChatGPT en Claude onthouden toch dingen?

Klopt, en het is een prima opstapje. ChatGPT onthoudt dingen tussen gesprekken, en Claude doet dat inmiddels ook. Voor losse taken scheelt dat echt. Maar zodra je het serieus inzet, loop je tegen drie problemen aan:

• Je weet niet precies wat het onthoudt. Het geheugen is een zwarte doos die de leverancier beheert.
• Het zit vast aan één model. Stap je over naar een beter model of een andere tool, dan blijft je geheugen achter.
• Het is niet van jou en niet gestructureerd. Je kunt het niet doorzoeken, niet versioneren, en je eigen agents kunnen er niet in werken.

Een eigen vault draait dat om: jij ziet elke regel, het reist mee naar elk model, en je agents lezen én schrijven erin. Je begint met ingebouwd geheugen, maar je eindigt met een tweede brein.

Hoe ik mijn tweede brein bouwde

Het klinkt groot, maar het zijn een paar onderdelen die samenwerken. Ik loop de onderdelen even langs.

De vault is het fundament. Eén map met platte tekst-bestanden in Obsidian. Notities over klanten, verslagen van gesprekken, ideeën, beslissingen, dagelijkse logs. Geen database, geen lock-in. Gewoon mappen en markdown die ik over tien jaar nog kan openen.

Claude Code is de motor. De CLI draait in die map en mag lezen en schrijven. Het weet hoe ik werk omdat ik dat heb vastgelegd in een instructiebestand (mijn CLAUDE.md): wie ik ben, hoe ik schrijf, wat wel en niet mag. Dat bestand is de grondwet. Elke sessie begint daarmee.

Een geheugenlaag bovenop. Losse geheugenbestanden die de agent bijwerkt, zodat hij over sessies heen onthoudt wat we eerder besloten. Niet de zwarte doos van een leverancier, maar bestanden die ik zelf kan lezen en corrigeren.

Een zoeklaag eroverheen. Een lokale zoekmachine (qmd) over de hele vault, op trefwoord én op betekenis. Daardoor kan ik mijn hele bedrijf een vraag stellen in plaats van door mappen te spitten.

De handen naar buiten. Koppelingen via MCP, een open standaard om AI aan andere software te koppelen, naar de tools die ik dagelijks gebruik: mijn agenda, mijn mail en MacWhisper voor transcriptie. De agent kan daardoor niet alleen denken maar ook doen.

Het brein groeit vanzelf. Een groot deel van de vault vult zichzelf. Mail, agenda-afspraken en getranscribeerde gesprekken komen automatisch als notities in de vault terecht, zonder dat ik iets overtik. Hoe meer ik werk, hoe rijker het geheugen wordt, zonder extra moeite.

Een tweede agent als controleur. Voordat er iets definitief is, kijkt een aparte, kritische agent het werk van de eerste na. Zo vang ik fouten en inconsistenties op voordat ze de deur uit gaan.

Een tweede brein is geen archief, het is een tuin

Een vault die je nooit opruimt, slibt dicht. Daarom hoort er onderhoud bij, en daar heb ik een paar vaste rituelen voor. Aan het eind van elke werkdag draait één commando dat alles van die dag vastlegt: wat ik deed, wat ik besloot, en welke fouten ik bijna opnieuw maakte. Periodiek ruim ik op, dubbele en verouderde notities eruit, zodat het geheugen scherp blijft in plaats van vol te lopen. Je hoeft geen strakke zettelkasten-discipline aan te houden; een beetje opruimen is genoeg. Een tweede brein dat je niet onderhoudt, wordt net zo'n rommellade als de systemen die je wilde vervangen.

Alles blijft lokaal

Dit is het stuk dat voor het MKB het zwaarst weegt. Mijn vault draait 100% lokaal. Het staat als platte tekst op mijn eigen machine, niet in de cloud van een leverancier. Privégegevens en klantinformatie verlaten mijn computer niet, tenzij ik daar expliciet toestemming voor geef. Gebruikt Claude Code een bestand, dan gaat die specifieke inhoud naar het cloud-model van Anthropic, en die stap zet ik elke keer bewust. De rest blijft lokaal.

En het kan nog strikter. Wil ik helemaal niets naar buiten sturen, dan draai ik een lokaal AI-model op mijn eigen machine en blijft alles binnenshuis. In de praktijk werk ik hybride. Bij mij draait dat op een Mac Studio: een lokaal model doet de zoeklaag en de simpele klussen zoals samenvatten en classificeren, en alleen het werk waar nuance bij komt kijken gaat naar het zwaardere Opus-model van Claude Code. Zo bepaal ik zelf wat lokaal blijft en wat naar een sterker model mag.

Wat privé moet blijven, verlaat mijn eigen machine niet.

Het recept

Je hoeft geen developer te zijn om hier iets mee te doen. Dit is de kortste route, van klein naar compleet.

Wat je nodig hebt:

• Obsidian, of eigenlijk elke map met markdown-bestanden
• Claude Code, de CLI
• Een CLAUDE.md met jouw context en jouw regels
• Een transcriptie-tool zoals MacWhisper die gesprekken automatisch wegschrijft
• Optioneel een lokale zoeklaag zoals qmd voor "vraag het je hele bedrijf"
• Een paar vaste commando's voor terugkerende klusjes

De stappen:

1. Maak je vault. Eén map, een paar submappen (klanten, gesprekken, ideeën, beslissingen, dagelijks). Begin klein.
2. Stel Claude Code in voor die map en schrijf je CLAUDE.md. Wie je bent, hoe je werkt, wat de agent wel en niet mag. Dit is het belangrijkste onderdeel.
3. Voeg een geheugenlaag toe, zodat de agent onthoudt wat er over sessies heen speelt.
4. Koppel je transcriptie, zodat gesprekken vanzelf in je vault terechtkomen zonder overtypen.
5. Leg een zoeklaag over de vault voor de "vraag het je hele bedrijf"-truc.
6. Bouw je eerste commando. Laat het aan het eind van de dag alles netjes opslaan.
7. Koppel de tools waarmee je werkt, zoals je agenda en mail.
8. Blijf verbeteren. Elke klus die je vaker dan twee keer doet, automatiseer je met een commando.

Wat het in de praktijk doet

Vier dingen die ik er dagelijks mee doe.

Een gesprek wordt vanzelf kennis. Ik neem een klantgesprek op. MacWhisper zet het automatisch om naar tekst, en een agent haalt daar de samenvatting, besluiten en actiepunten uit en schuift alles mijn vault in. Ik tik niets over. Een week later weet ik nog precies wat we afspraken, want het staat doorzoekbaar in mijn brein.

Mijn week aan input wordt content. Eén commando leest de video's en artikelen die ik die week opsloeg en destilleert er de bruikbare inzichten uit. Een tweede zet die inzichten om in concrete content-ideeën. Wat ik consumeer wordt zo automatisch grondstof voor wat ik maak.

Ik stuur mijn bedrijf ermee aan. Mijn agenda, mijn mail en mijn social posts lopen door datzelfde brein. De agent stelt voor, ik keur goed of stuur bij. Ik typ bijna nooit een antwoord vanaf nul. Dat is het verschil tussen een chatbot en een AI-agent die werk uit handen neemt.

Ik vraag mijn hele bedrijf iets. "Wat spraken we af met die klant in maart?" "Wat is de status van dat voorstel?" In plaats van door mappen en mails te zoeken, stel ik de vraag en het antwoord komt uit alles wat ik ooit heb vastgelegd. Mijn bedrijf is doorzoekbaar geworden.

Eigen commando's: van geheugen naar inzicht

Informatie onthouden en terugzoeken is pas het halve werk. De echte winst zit in synthese: een brein dat verbanden legt die ik zelf nooit had opgeschreven. Daarvoor schreef ik een handvol eigen commando's, korte opdrachten die ik in Claude Code intik en die in één keer mijn hele vault doordenken.

Dit zijn er vijf die ik bijna dagelijks gebruik. Per commando laat ik zien wat het oplevert.

/emerge haalt conclusies naar boven die mijn notities impliceren maar nergens benoemen. Mijn meest waardevolle commando.

/morningops stelt mijn ochtendbriefing samen uit mail, agenda, vault en git, en zet alles in één notitie.

/challenge houdt mijn aannames tegen het licht en zoekt op waar mijn eigen notities elkaar tegenspreken.

/drift vergelijkt mijn voornemens met mijn acties van de afgelopen 60 dagen. Zo zie ik wat ik vermijd.

/closeday sluit mijn werkdag af: het vat samen wat er gebeurde, haalt de actiepunten eruit en legt verbanden die ik anders zou missen.

Het punt is niet dat dit kant-en-klare functies zijn die iemand voor mij bedacht. Ik schreef ze zelf, in gewone taal, precies zoals ik werk. Het brein buigt naar mij, niet andersom.

Deze vijf zijn een greep uit een set van twaalf. Ik heb ze opgeschoond, losgemaakt van mijn eigen vault en op GitHub gezet, zodat je ze zelf kunt downloaden en gebruiken: de twaalf commando's staan open-source op GitHub. Ze draaien in elke AI-coding-agent (Claude Code, Cursor, Codex) op elke map met markdown-notities, en ze zijn read-only: ze lezen je notities en denken mee, maar schrijven er niets in. Clone de repo, draai het installatiescript en gebruik ze op je eigen vault.

DataDreamOS: mijn bedrijf draait erop

De vault begon als geheugen, maar is uitgegroeid tot het besturingssysteem van mijn bedrijf. Ik noem het DataDreamOS. Mijn hele administratie zit erin, en de agents werken er rechtstreeks mee.

Een paar voorbeelden uit de praktijk:

• Facturen maak ik vanuit de gegevens die al in de vault staan, niet in een los boekhoudpakket dat ik handmatig vul.
• Mijn financiën, leads en sales-pipeline houd ik erin bij: wie in welke fase zit, wat openstaat, wat eraan komt.
• Per klant en contactpersoon heb ik één overzicht: elk gesprek, elke afspraak en elke openstaande actie op één plek.
• Actiepunten en taken komen automatisch uit mijn gesprekken en notities, zodat er niets blijft liggen.

Het zijn geen losse tools naast elkaar, maar één systeem waarin alles samenkomt. Dat is het verschil tussen losse AI-trucjes en een bedrijf dat echt op AI draait.

Dit is agentic engineering, geen vibe-coding

Agentic engineering betekent dat je AI inzet als een ingenieur: met structuur en controle, niet op goed geluk. Hier zit het verschil dat ertoe doet. Wie AI weigert, raakt achterop. Maar wie AI loslaat zonder discipline, levert broos werk dat bij de eerste de beste uitzondering omvalt. Het optimum zit ertussenin: de discipline van een engineer, uitgevoerd via AI.

In de praktijk betekent dat eerst de structuur, dan pas de uitvoering. Ik leg vooraf vast wat wel en niet mag, hoe de output eruit moet zien, en welke stappen in welke volgorde komen. De prompt is niet het werk, de prompt is het resultaat van een doordachte workflow. Pas als dat raamwerk staat, laat ik de agent los.

Vibe-coding is een prompt intikken en hopen. Agentic engineering is een systeem bouwen dat je kunt optimaliseren, herhalen en uit handen geven.

Eerst de structuur, dan pas de uitvoering.

Wat dit voor jou betekent

Een tweede brein klinkt groot, maar de kern is simpel: je kennis staat op één plek en je AI kan erbij. Dat is het verschil tussen elke dag opnieuw beginnen en voortbouwen op wat je gisteren al wist.

Je hoeft mijn opstelling niet na te bouwen. Het principe is wat telt: zorg dat je context van jou is en op één doorzoekbare plek staat, en werk je proces uit vóór je er AI op loslaat. Een bedrijf dat zijn kennis verspreid heeft over zes systemen en AI er los overheen gooit, krijgt losse trucjes. Een bedrijf dat zijn geheugen op orde heeft en zijn workflow uittekent, krijgt een tweede brein dat meewerkt.

En dit is niet alleen voor bedrijven. Hetzelfde principe werkt net zo goed voor je persoonlijke leven: je plannen, je aantekeningen, je administratie, alles wat nu verdwijnt in losse apps en in je hoofd.

En dit is waar het echt om gaat. Het AI-model geeft je op zichzelf geen voorsprong, iedereen huurt hetzelfde model voor een paar tientjes per maand. Je voorsprong zit in wat het model niet heeft: jouw context, jouw gesprekken, jouw manier van werken, op één plek waar je AI bij kan. Dat is van jou, en dat kan niemand even namaken.

Dat is het verschil tussen AI als speeltje en AI als collega die nooit iets vergeet. Wil je weten hoe dat er voor jouw processen uitziet, dan is dat precies het werk dat ik doe: AI-oplossingen die in productie draaien.