Agentic OS op Claude Code: de drielaagse opbouw
De meeste mensen gebruiken Claude Code als een gokautomaat.
Open de terminal. Typ een prompt. Trek aan de hendel. Soms krijg je een werkende refactor. Soms krijg je een muur met kanttekeningen. Soms krijg je de helft van waar je om vroeg en een beleefde uitleg waarom de andere helft 'op dit moment niet aan te raden is'. U herhaalt de prompt dus opnieuw. Trek opnieuw. Misschien een woordje aanpassen. Trek opnieuw.
Ik deed dit gedurende de eerste acht maanden dat ik Claude Code gebruikte. Ik zei tegen mezelf dat het snelle engineering was. Dat was het niet. Het was gokken.
Wat uiteindelijk de cirkel doorbrak, was een methodologie die ik had opgepikt uit een video-samenvatting over het bouwen van een ‘agentisch besturingssysteem’ bovenop Claude Code, en vervolgens vormgegeven tegen mijn eigen rommelige realiteit van het runnen van vier merken en het pushen van grofweg 250 lange berichten door het systeem dit jaar. De methodologie bestaat uit drie lagen: architectuur, geheugen en waarneembaarheid. Saaie woorden. Enorme uitbetaling.
Dit bericht is de versie van die methodologie die ik daadwerkelijk gebruik, geschreven vanuit het veld, met de specifieke Claude Code-primitieven die ik gebruik en de dingen die ik heb geprobeerd en die het contact met echt werk niet hebben overleefd. Als je in de gokautomaatfase zit en begint te vermoeden dat er een betere manier is, dan heb je gelijk. Hier is het.
Het gokautomaatprobleem heeft een prijs
Voordat de methodologie zinvol is, moet de pijn specifiek zijn. Laat ik dus specifiek zijn.
A slot-machine workflow looks productive. Je bent bij de terminal. Er gebeuren dingen. Er wordt code gegenereerd. Maar het werk achter het werk – het deel waarin je de stem van je merk voor de elfde keer opnieuw uitlegt, dezelfde mapstructuur in een nieuwe sessie plakt, fouten oplost in een uitvoer die drijft omdat je vergat de beperking te vermelden die voor jou duidelijk was maar onzichtbaar voor het model – dat deel is onzichtbaar totdat je het meet.
Ik heb de mijne in maart gemeten. Tijdens een week van Claude Code-sessies besteedde ik ongeveer 35% van mijn prompttokens aan de context die ik het model al in een vorige sessie had gegeven. Niet het werk zelf. De opstelling voor het werk. Merkregels had ik op drie plekken opgeschreven. Mappaden Ik had het dinsdag getoond en vrijdag opnieuw getoond. Stembeperkingen ergens begraven in een CLAUDE.md waar ik nooit de moeite voor heb genomen om ernaar te verwijzen.
Erger nog: de variantie. Vraag Claude Code om maandag een mejba.me-bericht te schrijven en je krijgt één vorm. Vraag het vrijdag op dezelfde manier en je krijgt iets dat leest alsof het is geschreven door een verwante maar onbekende persoon. Dat is niet het model dat zich misdraagt. Dat ben ik als ik een ongestructureerde prompt tegen een staatloze engine uitvoer en verrast ben dat de uitvoer niet stabiel is.
De agentische OS-methodologie lost beide problemen op door het gokken te stoppen en de architectuur te starten. Drie lagen, in volgorde van impact: organiseer wat je doet (architectuur), onthoud wat je hebt gedaan (geheugen), zie wat er gebeurt (waarneembaarheid).
Zelfs als u alleen de eerste laag gebruikt, krijgt u de meeste waarde. Daar wil ik van tevoren eerlijk over zijn, want als je leest over een drielagensysteem is de verleiding groot om te proberen ze alle drie op zaterdag te bouwen. Niet doen. Bouw laag één. Leef erin. Voeg dan de volgende toe.
Laten we erop ingaan.
Laag één: architectuur — van willekeurige aanwijzingen tot een echt organigram
De eerste laag is degene die voor mij de gewoonte van gokautomaten heeft doorbroken. Het is ook degene die ik bijna had overgeslagen omdat het het minst technisch klinkt.
Het idee is eenvoudig. Denk niet langer aan Claude Code als een plaats waar u aanwijzingen typt. Begin het te zien als een organisatie met afdelingen, functiebeschrijvingen en standaardwerkprocedures. Concreet betekent dit dat u uw werk in vier geneste concepten organiseert:
- Domeinen — de brede gebieden waarin u feitelijk actief bent (contentcreatie, onderzoek, productiviteit, community, beveiliging)
- Taken — het terugkerende werk dat elk domein produceert (een blogpost, een scan van de concurrentie, een codebeoordeling, een merkaudit)
- Vaardigheden — gecodificeerde, herhaalbare instructies voor hoe u een specifieke taak goed kunt uitvoeren
- Automatiseringen: vaardigheden die werken op basis van een trigger in plaats van te wachten tot u ze activeert
Dit is niet abstract. In Claude Code komt elk van deze concepten overeen met een echte primitief. Vaardigheden leven als SKILL.md-bestanden met YAML-frontmatter. Subagenten leven als markdown-bestanden in .claude/agents/. Slash-opdrachten leven als bestanden in .claude/commands/. Automatiseringen zijn vaardigheden verpakt in een hook (SessionStart, PostToolUse) of een geplande trigger via de Claude Agent SDK. Het platform is hier al op ingericht. Je hoeft alleen maar de vorm te gebruiken.
Hoe een domein er eigenlijk uitziet in mijn configuratie
Ik beheer vier merken – mejba.me, ramlit.com, colorpark.io, xcybersecurity.io – plus een intern 'ops'-domein voor alles wat merken overschrijdt. Ik heb dus vijf domeinen. Elk domein heeft tussen de drie en zeven taken die ik feitelijk herhaaldelijk uitvoer, en aan elke taak is maximaal één vaardigheid verbonden.
Hier is de ingekorte structuur op schijf:
~/projects/agentic-os/
├── CLAUDE.md # root config (more on this below)
├── .claude/
│ ├── settings.json # permissions + hooks
│ ├── agents/ # subagents (one per role)
│ │ ├── aria.md # content engineer
│ │ ├── auditor.md # SEO + voice auditor
│ │ └── researcher.md # WebSearch + summary specialist
│ ├── commands/ # slash commands
│ │ ├── morning-scan.md
│ │ ├── post-from-video.md
│ │ └── brand-audit.md
│ └── skills/ # repeatable instructions
│ ├── write-blog-post/SKILL.md
│ ├── extract-video-summary/SKILL.md
│ └── seo-pass/SKILL.md
└── vault/ # memory layer (Obsidian)
├── raw/
├── wiki/
└── output/
Dat is de hele architectuur in één boom. Geen slim gereedschap. Geen eigen platform. Alleen mappen die Claude Code al native begrijpt.
Wat dit tot een organigram maakt en niet slechts tot een map, zijn de relaties tussen de stukken. De subagent aria.md leest de write-blog-post-vaardigheid. De slash-opdracht morning-scan roept de subagent researcher aan, die de vaardigheid extract-video-summary leest. Elk stuk doet één ding. Geen van hen dupliceert elkaar. Als ik wil veranderen hoe mejba.me-berichten worden geschreven, bewerk ik één bestand – de write-blog-post/SKILL.md – en elke aanroep in elk domein neemt de verandering over.
Dat is de saaie superkracht. Eén bron van waarheid voor elke mogelijkheid.
Een echte vaardigheid, geen speelgoedvaardigheid
Ik laat je zien hoe een vaardigheid er eigenlijk uitziet. Hier is een uitgeklede versie van degene die ik gebruik om gestructureerde samenvattingen uit videotranscripties te extraheren voordat ze blogposts worden:
---
name: extract-video-summary
description: Extract a structured summary from a video transcript or YouTube URL. Use when the user provides a video, transcript, or asks to "summarize this video" before writing a post.
---
You are extracting a structured summary that another agent will use as
source material for a blog post. The output must be:
1. **TLDR** — three sentences. The single most important takeaway.
2. **Key claims** — bullet list. One claim per bullet. No editorializing.
3. **Specific examples** — bullet list. Names, numbers, dates, tools.
4. **Quotes worth pulling** — direct quotes that would land in a blog.
5. **What the video gets wrong or oversimplifies** — be honest.
Rules:
- Do not soften claims. If the speaker said it, write it as they said it.
- If a claim is unverified, mark it `[unverified]` and move on.
- Save the result to `vault/raw/video-summaries/[slug].md` using
the video title as the slug.
Dat is het. Veertig regels als je de opmaak meetelt. Geladen in Claude Code via de Skill-tool, transformeert het een onbetrouwbare "samenvatting dit voor mij"-prompt in een deterministisch proces. Elke keer dezelfde vorm. Elke keer dezelfde bestandslocatie. Dezelfde downstream-agenten kunnen het lezen zonder te controleren welk formaat vandaag is verschenen.
Het belangrijkste aan een goede vaardigheid is wat het verwijdert, niet wat het toevoegt. Een vaardigheid neemt een vage vraag en verwijdert de variantie. Als je merkt dat je een lange, slimme vaardigheid schrijft, heb je waarschijnlijk nog niet besloten wat de taak eigenlijk is.
Automatisering: vaardigheden met een trigger
Een automatisering is een vaardigheid die zonder jou draait. In Claude Code is de goedkoopste manier om er een aan te sluiten via een haak in settings.json. Een SessionStart hook wordt geactiveerd wanneer een Claude Code-sessie begint. Een PostToolUse-haak vuurt nadat een gereedschap klaar is. Beide zijn geconfigureerd in settings.json en zijn gedocumenteerd in de officiële Claude Code hooks-referentie.
Hier is de ochtendtrendscan die ik uitvoer. Het is aangesloten als een slash-commando (/morning-scan) dat ik de meeste dagen handmatig activeer, maar op de dagen dat ik het geautomatiseerd wil hebben, wordt hetzelfde commando uitgevoerd vanuit een cronjob die gewoon naar claude -p "/morning-scan" gaat:
---
name: morning-scan
description: Aggregate AI news, competitor moves, and trending topics into a single daily brief. Save to vault/raw/scans/YYYY-MM-DD.md.
---
# Morning Scan
Run this every weekday morning before I open the terminal.
1. Use WebSearch to pull the top 5 stories from each of:
- Anthropic, OpenAI, Google AI launches in the last 24h
- HackerNews top 10 (filter to AI/dev/agent topics)
- r/ClaudeAI top posts of the day
2. For each story, write a 2-sentence summary. No fluff.
3. Flag anything that affects my multi-brand workflow:
- Claude Code changelog → tag #claude-code-update
- New AI tool launches → tag #stack-candidate
- Security/CVE news → tag #xcyber-relevant
4. Save the brief to vault/raw/scans/YYYY-MM-DD.md.
5. If anything in the brief is post-worthy for mejba.me, add a
line at the top: `POST CANDIDATE: [topic]`.
De vaardigheid is de wat. De cronjob is de trigger. Samen zijn ze een automatisering.
Voor de schonere versie zou u de Claude Agent SDK gebruiken om de uitvoering programmatisch te plannen en het resultaat naar een Slack-kanaal of uw eigen dashboard te posten. Die versie heb ik uiteindelijk gebouwd. De slash-command-plus-cron-versie leverde me 80% van de waarde op in 30 minuten.
Wanneer automatisering een valstrik wordt
Eerlijk gedeelte. Begin 2026 heb ik twee maanden lang overgeautomatiseerd. Veertien automatiseringen gebouwd voor de vier merken. Hooks die op elke Edit worden geactiveerd, geplande scans om de twee uur, een hook die elk bestand dat Claude Code aanraakt automatisch doorvoert. Het was prachtig op een whiteboard. In de praktijk was het een ramp.
Er gingen drie dingen kapot. Eerst vochten de haken met elkaar. Een PostToolUse-formatter bleef bestanden halverwege de bewerking opnieuw formatteren en doorstromen naar de volgende tooloproep. Ten tweede stegen de kosten enorm: elke geplande scan was een volledige Claude-sessie zonder limiet, en de rekening in maart was bijna het dubbele van die van februari. Ten derde: het lawaai. Veertien automatiseringen betekenden veertien Slack-meldingen per dag, waarvan ik de meeste dempte, wat het hele punt teniet deed.
Ik heb het teruggebracht tot vier automatiseringen. Ochtendscan. Kluisschoonmaak aan het einde van de dag. Wekelijkse merkstemaudit. Maandelijkse stapelbeoordeling. Al het andere werd een slash-commando dat ik uitvoer wanneer ik het echt wil. De les: automatisering is voor dingen die je toch al zou doen, niet voor dingen waarvan je zou willen dat iemand ze zou doen.
Als je helemaal opnieuw begint, bouw dan één vaardigheid, één slash-opdracht en nul automatiseringen op. Gebruik ze een week. Voeg het volgende pas toe als je de afwezigheid hebt gevoeld.
Ik heb de bredere filosofie voor het ontwerpen van vaardigheden besproken in de diepgaande analyse van Claude Code-vaardigheden waar bedrijven in 2026 voor betalen, en de tactische patronen om vaardigheden goedkoop te houden in de post over het besparen van vaardighedentokens van holbewoners – beide de moeite waard om te lezen voordat je begint met het codificeren van je eigen vaardigheden.
Dat is laag één. Domeinen, taken, vaardigheden, automatiseringen. Als u hier stopt met lezen en dit gewoon bouwt, loopt u al voor op 95% van de Claude Code-gebruikers. De volgende twee lagen maken het geheel compleet.
Laag twee: geheugen – de Obsidian-kluis en de CLAUDE.md die deze uitvoert
Laag één organiseert wat u doet. Laag twee geeft Claude Code een plek om te onthouden wat het deed.
Ik wil hier voorzichtig zijn, omdat 'geheugen' momenteel het meest overontwikkelde concept is in het agent-ecosysteem. Om de week verzendt een andere startup een "geheugenlaag voor Claude", dat wil zeggen, bij inspectie, een vectordatabase met een marketingbudget. Voor 90% van de persoonlijke workflows en workflows van kleine teams heb je dat niet nodig. U hebt een map met markdown-bestanden nodig en een configuratiebestand dat Claude Code vertelt wat erin staat.
Het patroon dat uiteindelijk bij mij klikte, is de Karpathy LLM Wiki-aanpak: Andrej Karpathy plaatste zijn versie op 3 april 2026 en ik heb een weekend besteed aan het opnieuw opbouwen van de mijne om deze te evenaren. De vorm bestaat uit drie mappen in een Obsidian-kluis: raw/, wiki/, output/. Elke map heeft een duidelijke taak. De LLM is de bibliothecaris en de auteur. Er is geen vectordatabase, geen inbedding, geen chunkingstrategie.
Ik schreef deze aanpak in detail in de Karpathy Obsidian RAG post – die post is de diepe duik over waarom het werkt. In dit gedeelte wordt besproken hoe het als geheugenlaag in het agentische besturingssysteem past.
De drie mappen, en waar ze voor dienen
De kluis is doodeenvoudig:
vault/
├── raw/ # ingestion, no organization required
│ ├── video-summaries/
│ ├── scans/ # morning-scan output lands here
│ ├── transcripts/
│ ├── research-clippings/ # Obsidian Web Clipper drops here
│ └── inbox/ # everything else, sorted later
│
├── wiki/ # codified knowledge, LLM-maintained
│ ├── index.md # master index, LLM-written
│ ├── claude-code/
│ │ ├── index.md
│ │ ├── skills.md
│ │ ├── hooks.md
│ │ └── agents.md
│ ├── brands/
│ │ ├── mejba-me-voice.md
│ │ ├── ramlit-positioning.md
│ │ └── colorpark-design-rules.md
│ └── ops/
│ ├── seo-rules.md
│ └── publishing-checklist.md
│
└── output/ # final deliverables
├── posts/
├── briefs/
└── decks/
raw/ is de stortplaats. Alles wat ik wil dat Claude Code uiteindelijk weet over land hier, ongesorteerd. Videotranscripties. Webknipsels (één klik via de Obsidian Web Clipper). Dagelijkse scanresultaten. Willekeurige spraaknotities die ik dicteer terwijl ik loop. De wrijving bij het innemen is opzettelijk bijna nul, want zodra ik moet nadenken over waar ik iets moet archiveren, stop ik met het archiveren van dingen.
wiki/ is waar de LLM zijn geld verdient. Volgens een terugkerend schema (of op aanvraag via een slash-commando) leest Claude Code raw/, identificeert nieuw materiaal dat nog niet is geïntegreerd, en werkt de wiki bij. Het schrijft artikelen in encyclopediestijl. Het onderhoudt de master index.md. Het verbindt gerelateerde concepten met behulp van [[wiki-style links]] die Obsidian native weergeeft. De wiki is het verzamelde inzicht van de LLM over alles in de kluis, geschreven in een formaat dat de volgende sessie efficiënt kan lezen.
output/ is de finishlijn. De laatste blogposts komen hier. Hier vindt u klantoverzichten. Decks voor aankomende workshops vind je hier. Alles wat geleverd is. De reden dat dit een eigen map krijgt, is zodat Claude Code snel kan antwoorden "wat heb ik verzonden?" zonder de rest van de kluis te doorzoeken.
Dat is de hele geheugenlaag. Drie mappen. Afwaardering. Vrij. Draagbaar.
Het CLAUDE.md op kluisniveau dat het met elkaar verbindt
Het enige bestand dat deze laag functioneel maakt, is de CLAUDE.md in de hoofdmap van de kluis. Het is de configuratie die Claude Code vertelt wat er in de mappen staat en hoe deze moeten worden behandeld. Zonder dit moet Claude elke sessie raden. Hiermee verlaagt u uw contextbepalende tokens met ongeveer 70%.
Hier is de feitelijke structuur van mij, licht geredigeerd:
# CLAUDE.md — Agentic OS kluisconfiguratie
## Doel
Deze kluis is de persistente geheugenlaag voor het agentische besturingssysteem. Het is
gezamenlijk onderhouden door mij en Claude Code. De kluis heeft drie topniveaus
mappen, elk met een specifieke rol.
## Maprollen
### rauw/
Onverwerkt bronmateriaal. Behandel dit als alleen-inname.
- Wijzig GEEN bestanden in raw/ behalve om nieuwe toe te voegen.
- Gebruik raw/ NIET als primaire bron bij het beantwoorden van vragen —
controleer altijd eerst wiki/ en val dan terug naar raw/ als de wiki
heeft een kloof.
- Nieuw materiaal van Obsidian Web Clipper, videosamenvattingen en
de ochtendscan-automatisering landt hier.
### wiki/
Gecodificeerde kennis, onderhouden door Claude Code. Behandel dit als de
primaire bron van waarheid voor alles wat is verwerkt.
- Begin altijd hier als u een vraag beantwoordt.
- Werk wiki/index.md altijd bij wanneer u een nieuw wiki-artikel maakt.
- Gebruik [[links in wiki-stijl]] om naar gerelateerde concepten te verwijzen.
- Als je tijdens het beantwoorden van een vraag een leemte in de wiki tegenkomt, let dan op
het onderaan de relevante index.md als TODO.
### uitvoer/
Definitieve resultaten. Behandel dit als voornamelijk gelezen.
- Schrijf hier alleen als er expliciet om een deliverable wordt gevraagd.
- Controleer bij het maken van een nieuw bericht output/posts/ om er zeker van te zijn
de slak is nog niet meegenomen.
## Workflowregels
1. Als ik om een blogpost vraag, lees dan de relevante wiki-sectie
eerst, dan raw/ voor elk nieuw materiaal sinds de wiki bestond
laatst bijgewerkt en schrijf het concept vervolgens naar output/posts/[slug].md.
2. Als ik nieuw materiaal aan raw/ toevoeg, verwerk het dan niet automatisch.
Wacht tot ik /update-wiki. uitvoer
3. Stemregels voor merken live in wiki/brands/. Laad altijd de
relevante voordat u in de stem van dat merk schrijft.
4. SEO-regels live in wiki/ops/seo-rules.md. Toepassen op elk bericht.
## Actieve merken
- mejba.me (persoonlijk, eerste persoon, gepassioneerd)
- ramlit.com (zakelijk, derde persoon, resultaatgericht)
- colorpark.io (ontwerp, eigenwijs, visueel)
- xcybersecurity.io (beveiliging, gezaghebbend, dringend)
Dat bestand is misschien 60 regels. Het doet meer voor de consistentie van mijn resultaten dan welke vaardigheid dan ook die ik heb geschreven. De reden is simpel: het elimineert gissen. Claude Code hoeft niet uit te zoeken waar dingen zich bevinden, waar elke map voor dient, of hoe om te gaan met dubbelzinnige verzoeken. De regels staan in het bestand, het bestand wordt elke sessie geladen en elke subagent erft de context.
Als u één configuratiebestand voor uw gehele installatie gaat schrijven, schrijf dan dit bestand.
Wat ik eerst probeerde en verliet
Twee geheugenexperimenten die het contact met echt werk niet overleefden.
Ten eerste: ik probeerde geheugen op te slaan in een Supabase-vectordatabase met een aangepaste MCP-server. Supabase als vectoropslag, OpenAI-inbedding, semantisch ophalen via mijn aantekeningen. Het werkte. Het was ook enorm overdreven ontworpen voor wat ik eigenlijk nodig had, namelijk 'onthoud wat we afgelopen dinsdag hebben besloten'. De kwaliteit van het ophalen was feitelijk slechter dan wanneer je Claude Code de prijsverlaging rechtstreeks liet lezen, omdat de stukjes midden in de zin zouden worden opgedeeld en gelijkenisscores bijna duplicaten zouden opleveren in plaats van de nuttigste noot. Na twee weekenden tunen heb ik het hele ding verwijderd.
Ten tweede: ik heb geprobeerd Claude Code elk nieuw onbewerkt bestand automatisch te laten verwerken zodra het werd toegevoegd - een PostToolUse hook die een wiki-update zou activeren bij elke schrijfbewerking naar raw/. De kosten waren wreed. Elke keer dat ik een lang artikel knipte, ontstond er een sessie waarin het artikel werd gelezen, werd beslist waar het in de wiki paste, soms een nieuw artikel werd geschreven en soms een bestaand artikel werd bijgewerkt. Sommige van die sessies waren meer dan 30.000 tokens. Als je dit tientallen keren per dag doet, worden de credits verbrand zonder dat dit proportionele waarde oplevert, omdat de meeste knipsels geen verwerking behoeven op dezelfde dag dat ze worden opgeslagen.
De oplossing was de expliciete opdracht /update-wiki in CLAUDE.md hierboven. Ik doe het één keer per week, op zondag. Het bundelt alle onbewerkte grondstoffen in één sessie, en de verhouding tussen de kosten per inzicht daalt met ongeveer 10x.
De les: geheugenlagen falen vanwege overarchitectuur (vector-DB's) of over-gretigheid (elke invoer automatisch verwerken). De Karpathy-mapstructuur plus een duidelijke CLAUDE.md plus een handmatige updateopdracht is het saaie midden dat echt werkt.
Dat is laag twee. Drie mappen, één configuratiebestand, één wekelijkse gewoonte. Nu heeft het systeem continuïteit.
Laag drie: Waarneembaarheid – een dashboard dat het besturingssysteem aan mensen blootstelt
Laag één organiseert wat u doet. Laag twee onthoudt wat je hebt gedaan. Laag drie is het deel dat ertoe doet als u niet langer de enige gebruiker bent.
Ik zal eerlijk zijn: ik heb laag drie als laatste gebouwd en lange tijd dacht ik dat ik die niet nodig had. Ik was de enige exploitant. Ik woonde in de terminal. De terminal was prima. Vervolgens probeerde ik de ochtendscanautomatisering aan een teamgenoot over te dragen, zodat ik een week op vakantie kon gaan, en het hele systeem viel niet omdat de technologie faalde, maar omdat ze drie CLI-commando's, een kluisstructuur en het verschil tussen een slash-commando en een subagent moest leren voordat ze één taak kon uitvoeren.
De terminal is een gracht. Voor mij is het een eigenschap. Voor alle anderen is het een muur.
Een dashboard is de derde laag van een agentisch besturingssysteem, omdat het de laag is waarmee het systeem mensen kan bedienen die voor de kost geen claude -p "..." willen typen. Dat omvat niet-technische teamgenoten, klanten, toekomstige jij op een zondagochtend wanneer typen als werk voelt, en iedereen die wil zien wat het systeem doet zonder logbestanden te lezen.
Wat het dashboard eigenlijk doet
Er is nog geen enkel officieel Claude Code-dashboard. Vanaf mei 2026 levert Anthropic de Claude Code-monitoringstack via OpenTelemetry – acht statistieken, waaronder het aantal sessies, tokengebruik, geschatte kosten en actieve tijd – en een gezond ecosysteem van door de gemeenschap gebouwde observatielagen (het claude-code-otel-project is degene die ik het meest heb gebruikt). Wat niemand uit de doos levert, is het controleoppervlak – het onderdeel dat je vaardigheden en automatiseringen als knoppen blootlegt.
Dat onderdeel bouw je dus zelf. De vorm die voor mij het beste werkte, is een kleine Next.js-app (misschien 600 regels in totaal) die vier dingen doet:
- Geeft elke vaardigheid en automatisering weer als een klikbare knop. Klik op "Ochtendscan" en het dashboard wordt weergegeven in
claude -p "/morning-scan"(of raakt programmatisch de Claude Agent SDK). De uitvoer stroomt terug naar de UI. 2. Houdt het gebruik bij. Wanneer werd elke vaardigheid voor het laatst uitgevoerd? Hoe lang duurde het? Hoeveel tokens kostte het? Welke automatiseringen zijn op schema verlopen en welke zijn geruisloos mislukt? 3. Toont recente kluiswijzigingen. Wat is er de afgelopen 24 uur aanraw/toegevoegd? Wat veranderde de laatste/update-wikiinwiki/? Wat is er deze week gepubliceerd opoutput/posts/? 4. Koppelt elke uitvoer terug naar Obsidian. Elk resultaat dat op het dashboard wordt weergegeven, heeft een link "Bron bekijken" waarmee het relevante markdown-bestand in Obsidian wordt geopend.
Volledige traceerbaarheid: elke claim die het systeem opduikt verwijst naar het bestand waar de claim vandaan komt.
Dat laatste is het belangrijkste. Zonder dit wordt het dashboard een magische doos waarin AI dingen doet en u erop vertrouwt. Hiermee is elke output met één klik controleerbaar. U ziet het resultaat, u klikt op de bron en u leest de prijsverlaging die de agent heeft gelezen. Geen enkele hallucinatie kan zich verbergen.
Wat het dashboard NIET hoeft te doen
Ik wil dit markeren omdat ik er een maand aan heb besteed. Het dashboard hoeft niet:
- Een volledige projectmanagementtool. Het is niet lineair. Het is geen vervanging voor uw taaktracker. Het is een besturingsoppervlak voor uw agentische besturingssysteem, punt.
- Een analyseplatform. Het bijhouden van tokenuitgaven is nuttig. Een op maat gemaakt analysemagazijn is dat niet.
- Een multi-tenant SaaS. Als u er een bouwt, besteedt u drie maanden aan verificatie en nul maanden aan daadwerkelijke workflowverbeteringen.
- Een realtime samenwerkingstool voor meerdere gebruikers. Jij bent de exploitant. Het dashboard is voor jou en misschien een of twee vertrouwde medewerkers.
Het dashboard dat ik heb gebouwd is een Next.js-app van één pagina met één route, geen authenticatie (het is alleen localhost) en een Postgres-instantie voor gebruikslogboeken. Totale bouwtijd: ongeveer 14 uur, verdeeld over twee weekenden. Het doet de vier bovenstaande dingen. Niets anders.
De statistieken die er echt toe doen
Van de acht statistieken die Claude Code standaard exporteert, verschijnen er vier op het startscherm van mijn dashboard:
- Tokens uitgegeven per vaardigheid, per week. Dit is de statistiek die betrapt dat automatiseringen kwaadaardig worden. De week dat ik de auto-wiki-hook liet afvuren, piekte deze grafiek 3x en kon ik precies zien welke vaardigheid verantwoordelijk was.
- Aantal uitvoeringen per automatisering. Welke automatiseringen daadwerkelijk worden uitgevoerd en welke ik stilletjes niet meer gebruik. Als een wekelijkse automatisering binnen drie weken niet is geactiveerd, is deze dood en verwijder ik deze.
- Vault delta. Hoeveel bestanden zijn er deze week gewijzigd in
raw/,wiki/,output/. Dit komt het dichtst in de buurt van "doet het systeem daadwerkelijk werk" dat ik heb gevonden. - Tijdstempel laatste run per vaardigheid. Wanneer heb ik dit voor het laatst aangeroepen? Vaardigheden die ik al 60 dagen niet heb uitgevoerd, worden gearchiveerd. Het systeem moet een levend organisme zijn, geen museum.
De andere vier statistieken (PR-aantal, coderegels, beslissingen over codebewerking, actieve tijd) zijn nuttig voor technische teams, maar minder nuttig voor een inhoudsoperatie. Uw kilometerstand zal variëren, afhankelijk van wat uw domeinen zijn.
Wat ik zou bouwen als ik vandaag zou beginnen
Als ik het dashboard in mei 2026 helemaal opnieuw zou opbouwen, zou ik beginnen met een van de open-source Claude Code observatiestapels – Cole Murray's claude-code-otel plus Grafana is een solide basis – en het besturingsoppervlak er bovenop vastschroeven. Het deel van de waarneembaarheid wordt opgelost door gemeenschapswerk. Het besturingsoppervlak is het deel dat u zelf moet schrijven, omdat het specifiek is voor uw vaardigheden en automatiseringen.
Probeer niet het hele ding in week één te bouwen. Het dashboard zou het ding moeten zijn waar u naar streeft als het uitvoeren van het besturingssysteem in de terminal niet meer snel aanvoelt. Als je nog steeds tevreden bent in de terminal, heb je deze nog niet nodig.
Dat is laag drie. Een besturingsoppervlak dat het besturingssysteem blootstelt aan mensen, met traceerbaarheid terug naar de kluis. Bouw het als laatste, bouw het klein, bouw het voor één gebruiker.
Wanneer zoveel structuur daadwerkelijk vruchten afwerpt
Ik heb geschreven alsof iedereen alle drie de lagen zou moeten bouwen. Dat zouden ze niet moeten doen. Het agentische besturingssysteem loont in specifieke situaties en is in andere situaties overdreven. Eerlijke beoordeling:
Bouw alle drie de lagen als je:
- Run meer dan één merk of één groot project (de structuur is voor elk merk hetzelfde)
- Geef werk over aan teamgenoten, klanten of aannemers die niet in een terminal wonen
- Produceer terugkerende deliverables volgens een schema (blogposts, briefings, audits, scans)
- Betrap jezelf erop dat je hetzelfde meer dan drie keer opnieuw uitlegt aan Claude Code
Bouw alleen laag één als je:
- Bent een solo-operator met één hoofdproject
- Gebruik Claude Code meestal voor eenmalige codeertaken
- U zit in de eerste maand dat u Claude Code serieus gebruikt (geef het de tijd voordat u architectuur toevoegt)
Sla het hele bericht over als je:
- Gebruik Claude Code af en toe voor persoonlijke projecten zonder terugkerende resultaten
- Ben nog aan het uitzoeken wat je domeinen en taken eigenlijk zijn
- Wil je eerst het platform leren kennen – overstructureren voordat je de primitieven begrijpt, is de op een na snelste manier om het platform op te geven
De reden dat het besturingssysteem voor mij de moeite waard is, is dat ik vier merken beheer en ongeveer 250 lange berichten per jaar verstuur. Zonder de structuur is de variantie de dood voor mij. Met de structuur heeft elk merk een stabiele stem, vertrekt elke post vanuit dezelfde steigers en daalt de tijd per post van ‘een volledige middag’ naar ‘negentig minuten inclusief onderzoek’. Dat is de wiskunde die de architecturale overhead de moeite waard maakt.
Als uw wiskunde anders is, is het antwoord anders. Ik wil er zeker van zijn dat ik niet iets verkoop dat niemand nodig heeft.
Wat ik op dag één zou overslaan
Ik krijg steeds de vraag: "Waar moet ik beginnen?" en ik blijf hetzelfde antwoord geven, dus laat me het expliciet maken. Als je dit bericht leest en besluit een agentisch besturingssysteem te bouwen, kun je deze week het volgende doen:
Alleen dag één, deze week. Kies één domein. Slechts één. Wat u momenteel het vaakst doet in Claude Code. Voor mij was dat contentcreatie. Voor jou kan het codebeoordeling, onderzoek of ontwerpwerk zijn. Kies er een.
Identificeer binnen dat domein drie taken. De drie dingen die u feitelijk herhaaldelijk doet binnen dat domein. Geen theoretische taken. Dingen die je de afgelopen maand minstens vier keer hebt gedaan.
Schrijf één vaardigheid per taak op. Gebruik het bovenstaande formaat. Maximaal veertig regels. Het doel is om variantie weg te nemen, niet om slim te zijn. Sla ze op in .claude/skills/.
Schrijf één CLAUDE.md. Eén paragraaf per taak, waarin je uitlegt wat je wilt en waar de uitvoer naartoe moet. Geen boek. Een pagina.
Stop daar.
Bouw de kluis nog niet. Bouw het dashboard nog niet. Bouw geen automatiseringen. Gebruik de architectuur twee weken lang. Let op waar het breekt en waar het zingt. Pas de vaardigheden aan op basis van wat u leert van echt gebruik.
Na twee weken, als de architectuur stand heeft gehouden, begin je de afwezigheid van geheugen te voelen. Dat is wanneer je de kluis bouwt. Als je na nog eens twee weken met iemand anders werkt, begin je de afwezigheid van het dashboard te voelen. Dat is het moment waarop u het dashboard bouwt.
Het samengestelde belang van deze aanpak is dat elke laag een probleem oplost dat je al hebt gevoeld. Je bouwt geen speculatieve infrastructuur. Je dicht gaten die je kunt benoemen.
Wat dit verandert aan de manier waarop u Claude Code gebruikt
De diepste verandering die het agent-besturingssysteem teweegbrengt, is niet tactisch. Het is psychologisch.
Voordat ik deze structuur had, voelde het alsof elke Claude Code-sessie alle kanten op kon gaan. Ik zou de terminal openen met een vage bedoeling, iets typen en het model laten doen wat het zou doen. De variantie voelde als creativiteit. Dat was het niet. Het was willekeur met goede PR.
Na de structuur heeft elke sessie een vorm. Ik open Claude Code en weet welke vaardigheid wordt uitgevoerd, welke subagent deze gaat afhandelen, in welke map de uitvoer terechtkomt en welke downstream-agent deze vervolgens gaat ophalen. De sessie voelt minder als aansporing en meer als verzending. Ik werk niet meer samen met een gokautomaat. Ik gebruik een organigram.
Die verschuiving, meer dan welke individuele tool of truc dan ook, heeft ervoor gezorgd dat Claude Code voor mij van "interessante tool" naar "besturingssysteem" is gegaan. Het is de methodologie die mij daar heeft gebracht. De drie lagen houden het op zijn plaats.
Als je je nu in de gokautomaatfase bevindt, is dit het enige wat ik wil dat je uit dit bericht haalt: de uitweg is geen betere prompt. Het is een betere architectuur. Kies deze week één domein. Schrijf drie vaardigheden op. Schrijf een CLAUDE.md. Stop met het trekken aan de hendel en begin met het uitvoeren van de handeling.
Ik ben in de terminal, maar ik gok niet meer.
Veelgestelde vragen
Wat is een agentisch besturingssysteem in Claude Code?
Een agentisch besturingssysteem is een gestructureerd raamwerk dat Claude Code verandert van ad-hocprompts in een gelaagd systeem met drie lagen: architectuur (domeinen, taken, vaardigheden, automatiseringen), geheugen (een Obsidian-kluis met raw-, wiki- en uitvoermappen plus een CLAUDE.md op kluisniveau) en observatie (een dashboard dat vaardigheden en automatiseringen blootlegt als klikbare knoppen met gebruiksstatistieken). Het maakt gebruik van de oorspronkelijke primitieven van Claude Code, zoals vaardigheden, subagents, hooks en slash-opdrachten, in plaats van aangepaste gereedschappen. Zie de drielaagse uitsplitsing hierboven voor het volledige implementatietraject.
Heb ik een Obsidian-kluis nodig om Claude Code effectief te kunnen gebruiken?
Nee — Obsidian is een goede optie voor de geheugenlaag, geen vereiste. De kluislaag is slechts een map met markdown-bestanden met een CLAUDE.md op kluisniveau die Claude Code vertelt waar elke map voor is. U kunt dezelfde structuur in elke gewone map implementeren; Obsidian voegt gratis, mensvriendelijke weergave, links in wiki-stijl en de Web Clipper toe voor opname.
Waarin verschilt een Claude Code-vaardigheid van een slash-opdracht?
Een vaardigheid is een SKILL.md-bestand met YAML-frontmatter dat een herhaalbare taak beschrijft en automatisch wordt geladen wanneer dit relevant is. Een slash-opdracht is een markdown-bestand in .claude/commands/ dat u expliciet aanroept met /command-name. Vaardigheden gaan over vermogen; slash-opdrachten gaan over invocation. De meeste goedgebouwde systemen hebben vaardigheden die worden geactiveerd door slash-opdrachten.
Wat is een Claude Code-automatisering en hoe bouw ik er een?
Een automatisering is een vaardigheid die wordt uitgevoerd op basis van een trigger in plaats van te wachten tot u deze aanroept. De goedkoopste manier om er een aan te sluiten is via een hook in .claude/settings.json - een SessionStart of PostToolUse hook die het relevante slash-commando afvuurt. Voor geplande automatiseringen werkt een cron-taak die uitmondt in claude -p "/your-command" prima. De Claude Agent SDK biedt een programmatische versie als u daar overheen groeit.
Hoeveel kost het uitvoeren van een agentisch besturingssysteem op Claude Code?
Laag één (architectuur) kost niets extra's: u betaalt hoe dan ook voor Claude Code. Laag twee (kluis) is gratis als u Obsidian gebruikt. Laag drie (dashboard) omvat alleen uw hostingkosten — doorgaans minder dan $10/month voor een configuratie met één operator. De variabele kosten zijn afkomstig van automatiseringen: een slecht afgestemde automatisering kan uw tokenuitgaven verdubbelen. Daarom beperk ik automatiseringen tot vier en bekijk ik wekelijks de token-per-vaardigheidsstatistieken.
Kan ik een agentisch besturingssysteem overdragen aan een niet-technische teamgenoot?
Dit is precies waar laag drie (het dashboard) voor is gebouwd. De terminal is een gracht voor technische operators en een muur voor alle anderen. Een dashboard dat vaardigheden en automatiseringen als knoppen weergeeft, waarbij de uitvoer naar de UI wordt gestreamd en bronlinks terug naar Obsidian, laat een niet-technische teamgenoot het systeem besturen zonder ooit de CLI aan te raken. Zonder het dashboard is de overdracht pijnlijk.
Laten we samenwerken
Wilt u AI-systemen bouwen, workflows automatiseren of uw technische infrastructuur schalen? Ik help je graag.
- Fiverr (aangepaste builds en integraties): fiverr.com/s/EgxYmWD
- Portfolio: mejba.me
- Ramlit Limited (ondernemingsoplossingen): ramlit.com
- ColorPark (ontwerp en branding): colorpark.io
- xCyberSecurity (beveiligingsdiensten): xcybersecurity.io
