Claude Code, Skills & de Agentic AI Tech Stack

Ik bouw hier letterlijk mee. Deze website — seanvermond.com — is gemaakt met Claude Code. Niet "geïnspireerd door" of "deels gegenereerd met." Nee. De componenten, de API-routes, de CMS-integratie, de deployment-configuratie. Claude Code schreef de code, ik stuurde de architectuur. En het resultaat is een productie-website die draait op Next.js 15, content ophaalt uit Payload CMS, en gedeployed wordt via Coolify op mijn eigen Hetzner-server. Geen template. Geen page builder. Code, geschreven door AI, aangestuurd door een architect.

Laat dat even inzinken. Want een jaar geleden zou dat een onmogelijk verhaal zijn geweest. Twee jaar geleden science fiction.

Ik merk het bij elk gesprek dat ik voer met ondernemers en teams. Ze snappen dat AI krachtig is. Ze gebruiken het als slimme assistent. Maar zodra het woord "bouwen" valt — een workflow automatiseren, een tool laten draaien, iets structureels neerzetten — dan haken ze af. "Daar heb je toch een developer voor nodig?" Of: "Dat is toch alleen voor techbedrijven?"

Nee. Niet meer. En in dit artikel laat ik je zien waarom.

We gaan het hebben over Claude Code, het Skills-systeem, MCP-servers en de complete agentic AI tech stack. Niet als abstract concept — ik leg je precies uit hoe de stukken in elkaar passen, met een concreet voorbeeld dat je kunt natekenen. En ik beloof je: de drempel is lager dan je denkt.

Van chat naar code: wat is Claude Code?

Laten we beginnen bij het begin. Claude Code is een tool van Anthropic — het bedrijf achter Claude — waarmee je AI niet alleen kunt bevragen, maar kunt laten bouwen. Het draait in je terminal (dat zwarte scherm waar developers hun magie doen) en het kan code schrijven, bestanden aanmaken, commando's uitvoeren en met je bestaande tools praten.

Maar het is meer dan een code-generator. Claude Code begrijpt je hele project. Het leest je bestanden, snapt de structuur, volgt je conventies en bouwt daarop voort. Alsof je een senior developer naast je hebt zitten die je codebase kent en meedenkt over de architectuur.

Ik kan dit bevestigen uit eerste hand. Als ik Claude Code open in mijn portfolio-project, kent het mijn mappenstructuur, mijn designsysteem (Syne voor headings, DM Mono voor body, scherpe hoeken, navy kleurenpalet), mijn API-keys, mijn deployment-setup. Ik hoef niet elke keer opnieuw uit te leggen hoe mijn project werkt. Het weet het. En dat maakt het verschil tussen "AI als hulpmiddel" en "AI als teamlid."

"Oké Sean, maar ik ben geen developer. Waarom zou mij dit interesseren?"

Goede vraag. En het antwoord is simpel: omdat Claude Code de grens tussen "gebruiker" en "bouwer" vervaagt. Je hoeft geen code te kunnen lezen om te begrijpen wat er mogelijk is. En je hoeft geen developer te zijn om te sturen wat er gebouwd wordt. Als je een duidelijk doel kunt formuleren, kan Claude Code het uitvoeren.

Is het plug-and-play? Nee. Moet je enige technische interesse hebben? Ja. Maar de tijd dat je vijf jaar informatica moest studeren om iets digitaals te bouwen, is definitief voorbij.

Het Skills-systeem: herbruikbare instructies

Hier wordt het pas echt interessant. Claude Code heeft een Skills-systeem. En als je begrijpt wat dat doet, begrijp je waarom agentic AI zo krachtig is.

Een Skill is in essentie een set instructies die je kunt hergebruiken. Denk aan een recept. Je schrijft één keer op hoe je een bepaalde taak uitvoert, en daarna kan Claude Code dat recept steeds opnieuw volgen. Zonder dat je het opnieuw hoeft uit te leggen. Zonder dat je de context opnieuw hoeft te geven.

Een voorbeeld

Stel: je wilt dat Claude Code blogartikelen schrijft in jouw huisstijl. Je tone of voice, je structuur, je woordkeuze, je formatting. In plaats van dat je bij elk artikel opnieuw al die instructies meegeeft, maak je een Skill aan:

"Schrijf blogartikelen in het Nederlands. Tone: persoonlijk, alsof je tegen een vriend praat. Gebruik metaforen en concrete voorbeelden. Structuur: pakkende intro, H2's met duidelijke koppen, conclusie met call-to-action. Lengte: 1.500-2.000 woorden."

Die Skill sla je op. En de volgende keer dat je zegt "schrijf een blog over X", weet Claude Code precies hoe. Het is alsof je een nieuwe medewerker hebt ingewerkt — je doet het één keer grondig, en daarna draait die medewerker zelfstandig.

Ik heb inmiddels een hele bibliotheek aan Skills opgebouwd. Een voor blogartikelen in mijn stijl. Een voor het opzetten van nieuwe Next.js-pagina's volgens mijn conventies. Een voor het deployen naar Coolify. Een voor SEO-optimalisatie. Het zijn mijn digitale standaardprocedures — en ze maken me minstens drie keer zo snel als wanneer ik alles handmatig zou moeten instrueren.

Waarom dit meer is dan een fancy prompt

Je denkt misschien: "Dat is toch gewoon een opgeslagen prompt?" En ja, op het eerste gezicht lijkt het daarop. Maar er zijn twee cruciale verschillen.

Ten eerste: Skills combineren met tools. Een Skill vertelt Claude Code niet alleen hoe het iets moet doen, maar ook waarmee. Welke bestanden het mag lezen, welke API's het mag aanroepen, welke databases het mag doorzoeken. Het is niet alleen een instructie — het is een complete werkbeschrijving inclusief gereedschap.

Ten tweede: Skills zijn composable. Je kunt Skills combineren. Een "research" Skill die informatie opzoekt, gevolgd door een "schrijf" Skill die er een artikel van maakt, gevolgd door een "review" Skill die het controleert. Dat is geen prompt meer — dat is een workflow. En workflows zijn de basis van agentic AI.

MCP-servers: AI praat met je tools

In het vorige artikel had ik het over het Model Context Protocol. Laten we daar nu concreter over worden, want MCP is het stuk van de puzzel dat alles mogelijk maakt.

MCP staat voor Model Context Protocol. Het is een open standaard die definieert hoe AI-modellen communiceren met externe tools en databronnen. Denk aan USB, maar dan voor AI. Het maakt niet uit welk model je gebruikt of welke tool je wilt aansluiten — als ze allebei MCP spreken, werken ze samen.

Hoe het werkt in de praktijk

Stel: je gebruikt Claude Code en je wilt dat het je projecten in Asana kan bekijken en bijwerken. Zonder MCP zou je een custom integratie moeten bouwen. Code schrijven die de Asana API aanroept, authenticatie regelt, data transformeert — uren werk.

Met MCP start je een Asana MCP-server. Dat is een klein programmaatje dat tussen Claude Code en Asana zit. Claude Code zegt: "Ik wil de taken in project X zien." De MCP-server vertaalt dat naar een Asana API-call, haalt de data op, en geeft het terug aan Claude Code. Klaar. Geen custom code. Geen uren prutsen.

En het mooie is: dit werkt met alles. Databases, CRM-systemen, e-mailtools, kalenders, bestandssystemen, version control, cloud storage — er zijn inmiddels duizenden MCP-servers beschikbaar. Het ecosysteem is in een paar maanden geëxplodeerd.

Om het concreet te maken: mijn eigen Claude Code-setup heeft MCP-servers voor Coolify (mijn deployment-platform), een memory-server (een knowledge graph die onthoudt wat ik eerder heb gedaan), Perplexity (voor real-time webresearch), Firecrawl (om websites te scrapen), Playwright (voor browser-automatisering), en DataForSEO (voor SEO-data). Dat zijn zes extra "zintuigen" die Claude Code kan gebruiken bovenop zijn eigen capaciteiten. Zes tools die het kan aanroepen wanneer het dat nodig acht — zonder dat ik hoef te zeggen "gebruik nu Perplexity." Het beslist zelf.

Wat dit betekent voor jou

Dit betekent dat je AI-agent niet meer beperkt is tot tekst genereren. Je agent kan:

• Je CRM doorzoeken en bijwerken
• E-mails lezen en versturen
• Bestanden aanmaken en bewerken
• Databases bevragen
• Projecten beheren
• Websites analyseren
• En nog veel meer

Elke MCP-server voegt een nieuwe vaardigheid toe aan je agent. Het is letterlijk alsof je je medewerker een nieuwe tool geeft. "Hier, nu kun je ook met Excel werken." "Hier, nu heb je ook toegang tot het CRM." Elke tool maakt de agent capabeler.

De agentic stack: model + tools + memory + orchestration

Goed, we hebben de puzzelstukken. Laten we ze nu samenleggen. Want de echte kracht zit niet in de individuele componenten — het zit in hoe ze samenwerken. Dit is de agentic AI tech stack, en hij bestaat uit vier lagen.

Laag 1: Het model (het brein)

Onderaan staat het AI-model. Claude, GPT-5, Gemini — dat maakt in principe niet uit. Het model is het brein dat kan redeneren, plannen en tekst genereren. Zonder model geen agent. Maar een model alleen is ook nog geen agent — het is potentieel zonder uitvoering.

De keuze van model hangt af van je use case. Voor complexe redenering en lange taken heb je een krachtig model nodig. Voor simpele, repetitieve taken kun je een sneller en goedkoper model inzetten. In de praktijk gebruiken de meeste agentic systemen een mix: een groot model voor de moeilijke beslissingen, een kleiner model voor de routine.

Laag 2: Tools (de handen)

De tweede laag is het gereedschap. MCP-servers, API-integraties, code-executie — alles waarmee het model de echte wereld kan beïnvloeden. Tools zijn wat een agent onderscheidt van een chatbot. Zonder tools kan het model alleen praten. Met tools kan het handelen.

De kunst is om de juiste tools beschikbaar te maken. Te weinig en je agent is beperkt. Te veel en je agent raakt verward. Begin met de tools die direct relevant zijn voor je use case en breid uit naarmate je agent volwassener wordt.

Laag 3: Memory (het geheugen)

De derde laag is geheugen. En dit is waar het voor veel mensen abstract wordt, maar het concept is simpel: geheugen zorgt ervoor dat je agent leert en onthoudt.

Er zijn twee soorten geheugen. Korte-termijn geheugen is de context van het huidige gesprek of de huidige taak. Wat is er tot nu toe besproken? Welke stappen zijn al uitgevoerd? Dit is vergelijkbaar met je werkgeheugen — wat je actief in je hoofd houdt terwijl je aan iets werkt.

Lange-termijn geheugen is wat de agent onthoudt over sessies heen. Je voorkeuren, eerdere projecten, geleerde lessen. Dit kan zo simpel zijn als een bestand met notities, of zo geavanceerd als een knowledge graph — een netwerk van verbonden feiten en relaties.

Memory is wat een agent persoonlijk maakt. Zonder memory is elke interactie een eerste ontmoeting. Met memory bouwt de agent een relatie op — het kent je, het snapt je context, het wordt steeds effectiever. Mijn eigen memory-server bevat inmiddels alles over mijn serverinfrastructuur, mijn API-keys, mijn projectconventies, en zelfs mijn voorkeuren voor hoe ik code wil structureren. Claude Code hoeft me nooit meer te vragen hoe ik mijn Coolify-deployments configureer — het weet het.

Laag 4: Orchestration (de dirigent)

De bovenste laag is orchestration. Dit is de laag die alles coördineert. Welk model wordt voor welke taak ingezet? Welke tools zijn nodig? Wanneer moet er informatie uit het geheugen worden opgehaald? Wat gebeurt er als een stap faalt?

Bij een enkele agent is orchestration relatief simpel — het model plant en voert uit. Maar bij een multi-agent systeem wordt orchestration cruciaal. Wie doet wat? In welke volgorde? Hoe wordt informatie doorgegeven tussen agents? Wanneer is de taak klaar?

Dit is waar frameworks als LangGraph, CrewAI en AutoGen hun waarde bewijzen. Ze bieden de structuur waarbinnen agents samenwerken — de speelregels, de communicatiekanalen, de foutafhandeling. Ze zijn de dirigent van het orkest.

Concreet voorbeeld: hoe ik deze website bouwde

Genoeg abstractie. Laten we het concreet maken met iets dat ik daadwerkelijk heb gedaan. Want theoretische voorbeelden over e-mail-agents zijn leuk, maar ik wil je laten zien hoe de agentic stack eruitziet in mijn dagelijkse werk.

Het doel

Drie websites bouwen en lanceren in twee weken: seanvermond.com (dit portfolio), afdeling-ai.nl (mijn AI-consultingsite), en bobscocktailclub.com (een cocktailplatform). Alle drie Next.js 15, alle drie gekoppeld aan dezelfde Payload CMS, alle drie gedeployed op dezelfde server.

De stack

• Model: Claude (via Claude Code in de terminal)
• Tools (MCP): Coolify MCP-server (deployment), Memory MCP-server (projectcontext), Perplexity (research voor content), Firecrawl (website-analyse)
• Memory: Knowledge graph met alle serverdetails, API-keys, projectconventies, en eerdere beslissingen
• Orchestration: Ik als architect, Claude Code als uitvoerder — maar met genoeg autonomie om zelf beslissingen te nemen binnen de kaders die ik stel

Hoe het werkte

1. Ik definieerde de architectuur: Next.js 15 met App Router, Payload CMS als headless CMS, Tailwind voor styling, Coolify voor deployment.
2. Claude Code zette de projectstructuur op, inclusief alle configuratiebestanden, de CMS-integratie, en de API-routes.
3. Voor elke pagina gaf ik een briefing — "bouw een bento-grid homepage met deze secties" — en Claude Code schreef de componenten, de styling, en de data-fetching.
4. Bij problemen debugde Claude Code zelf. Het las error logs, identificeerde de oorzaak, en fixte de bug. Soms sneller dan ik het handmatig had kunnen doen.
5. Deployment ging via de Coolify MCP-server — Claude Code kon direct de status van mijn applicaties checken en deployments triggeren.

Totale bouwtijd voor drie complete websites: twee weken. Inclusief CMS-configuratie, content, en deployment. Zonder Claude Code was dit twee maanden werk geweest. Minimaal.

Wat je hiervoor nodig hebt

En hier is het mooie: de onderdelen zijn beschikbaar. Claude Code als basis. MCP-servers voor je tools. Een memory-bestand of knowledge graph voor context. Skills die definiëren hoe de agent werkt.

Is het plug-and-play? Eerlijk: nog niet helemaal. Je moet het opzetten, configureren, testen en bijsturen. Maar de technische drempel is een fractie van wat het een jaar geleden was.

De drempel is lager dan je denkt

En dat is eigenlijk de kernboodschap van dit artikel. De agentic AI stack — model, tools, memory, orchestration — klinkt intimiderend. Maar elke laag apart is begrijpelijk. En de tools om ze samen te brengen worden elke maand toegankelijker.

Je hoeft geen AI-engineer te zijn om een agent te bouwen. Je moet begrijpen wat de componenten doen, hoe ze samenwerken, en waar je ze vindt. De rest is configuratie en iteratie.

Begin met iets kleins. Eén MCP-server aansluiten. Eén Skill schrijven. Eén simpele agent die één repetitieve taak overneemt. Bouw van daaruit. Leer van de fouten. Breid uit als je er klaar voor bent.

In mijn artikel over de tech stack schreef ik over de tools die de AI-wereld aandrijven. Die tools zijn in een halfjaar tijd samengekomen tot een coherente stack. Het is niet langer een verzameling losse onderdelen — het is een platform. En dat platform staat klaar om gebruikt te worden.

Conclusie: van consument naar bouwer

De afgelopen twee jaar waren we consumenten van AI. We gebruikten het als slim gereedschap. We typten vragen en kregen antwoorden. Dat was waardevol — en dat blijft het.

Maar de volgende fase is bouwen. Niet alleen chatten met AI, maar AI inzetten als bouwsteen in je werkprocessen. Agents die zelfstandig taken uitvoeren. Tools die naadloos samenwerken. Geheugen dat groeit met elk gebruik. Systemen die complexe problemen opsplitsen en stuk voor stuk oplossen.

Claude Code, Skills, MCP-servers, multi-agent frameworks — het zijn de instrumenten van een nieuw tijdperk. Je hoeft ze niet allemaal vandaag te beheersen. Maar je moet weten dat ze bestaan, wat ze doen, en hoe ze samenhangen.

Want de bedrijven die het beste presteren in 2026 en daarna, zijn niet de bedrijven met de meeste developers. Het zijn de bedrijven die het beste begrijpen hoe ze AI laten werken. En dat begint met de stack begrijpen.

De drempel is lager dan je denkt. De tools zijn er. De standaarden zijn er. De enige vraag is: wanneer begin je?

Dit is deel 16 van de serie "Reis door AI". In het volgende artikel laten we de code helemaal los en kijken we hoe je AI-workflows bouwt zonder ook maar één regel code te schrijven.