Claude Code tutorial voor beginners: de uitleg

Wanneer gebruik je Claude Code en wanneer niet?

Claude Code is de juiste keuze zodra er bestanden bij komen kijken. Chat beantwoordt een vraag en levert tekst, Claude Code maakt een map aan, schrijft er bestanden in, test ze en publiceert ze. Dat verschil bepaalt waar je begint.

Wat heb je nodig om te beginnen?

Een betalend abonnement, een map en twee hulpprogramma's. Dat is alles. Je kan Claude Code gebruiken in je terminal, in VS Code of JetBrains, in de desktop-app of in je browser. Wie nog nooit een terminal opende, begint het makkelijkst in de desktop-app, want daar zit Claude Code al in.

1. Installeer Claude Code met één commando in je terminal, of open de desktop-app en sla die stap over. De installatie is native, dus Node of npm heb je er niet meer voor nodig.
2. Werk je op Windows zonder WSL, installeer dan Git for Windows erbij. Dat is niet verplicht, maar het geeft Claude Code de Bash-opdracht in plaats van PowerShell.
3. Maak een lege map aan voor dit project en open die map in Claude Code.
4. Laat Claude die map initialiseren, zodat er een CLAUDE.md ontstaat met wat het over je project moet weten.

Die derde stap klinkt triviaal en is het niet. Claude Code werkt binnen de map die je aanwijst. Wijs je je volledige documentenmap aan, dan geef je toegang tot alles wat daarin staat en wordt elke zoekactie trager. Een map per project houdt het overzichtelijk en beperkt wat er mis kan gaan.

Welke instelling kost je het meeste tijd?

De permissiestand. Standaard vraagt Claude Code toestemming voor acties, en dat is precies waar beginners uren verliezen: je geeft een opdracht, je gaat iets anders doen, je komt twintig minuten later terug en er is niets gebeurd omdat het nog op jouw antwoord wacht.

Veel tutorials raden aan om meteen alles toe te staan, omdat fouten snel te herstellen zijn en wachten duur is. Die redenering klopt zolang je in een wegwerpmap werkt. Ze klopt niet op een bestaande website, een map met klantbestanden of een repository die je elke dag gebruikt. Daar is de ene fout die wel schade doet, duurder dan alle gewonnen minuten samen.

De praktische middenweg: plan eerst voor alles wat meerdere bestanden raakt, en werk daarna zonder onderbrekingen. Je ziet dan vooraf welke bestanden veranderen en kan corrigeren voor er iets gebeurt.

Waarom heb je GitHub nodig als je niet programmeert?

Omdat je anders geen rem hebt. Versiebeheer bewaart elke versie van elk bestand, zodat je kan terugkeren naar de staat van vijf minuten geleden. Dat was altijd al nuttig. Het wordt noodzakelijk zodra iets anders dan jij je bestanden aanpast, want een agent herschrijft honderd bestanden sneller dan jij ze kan nakijken.

Dat is ook het eerlijke antwoord op de permissievraag hierboven. Wie alles toestaat doet dat zelden uit roekeloosheid, maar omdat elke fout bij hem één commando kost om ongedaan te maken. Zonder versiebeheer heb je dat vangnet niet en betekent dezelfde instelling iets heel anders.

Die commando's hoef je niet te leren. Je vraagt Claude Code om de repository aan te maken en om te committen, en het doet het. Wat je wel zelf bepaalt is het ritme, en daar gaat het bij beginners mis: ze vragen één commit aan het eind van de dag. Dan heb je één groot blok met acht uur werk erin, en terugdraaien betekent alles kwijt. Vraag een commit telkens als iets werkt, ook als dat tien keer op een dag is. Elke commit is een punt waar je naar terug kan.

Twee dingen horen nooit in een repository: je sleutels en wachtwoorden, en bestanden die een hulpprogramma zelf genereert. Hoe je die sleutels wel bewaart staat verderop. Zet je repository bovendien op privé zolang er niets in staat dat je publiek wil hebben, want een publieke repository is door iedereen te lezen, ook door wie naar sleutels zoekt.

GitHub is daarnaast de plek waar je hostingpartij je site vandaan haalt. Dat is de reden dat de twee stappen bij publiceren in deze volgorde staan: eerst naar de repository, dan naar de host.

Hoe maak je iets dat er goed uitziet?

Door een voorbeeld te geven in plaats van het te beschrijven. Dat is de belangrijkste ontwerptruc en hij werkt omdat beschrijvingen als strak en modern niets vastleggen, terwijl een afbeelding dat wel doet.

De werkwijze: zoek een ontwerp dat je mooi vindt, maak er een schermafbeelding van, voeg die toe aan je gesprek en vraag Claude om die stijl te volgen. Dat werkt voor een presentatie, een website en een dashboard. Wil je dat de stijl terugkomt in alles wat je later maakt, leg hem dan een keer vast in een ontwerpsysteem en verwijs daar telkens naar.

Een tweede truc die veel tijd scheelt: vraag om het absolute pad van wat Claude net maakte. Dat is de locatie van het bestand op je computer. Plak dat pad in je browser en je ziet het resultaat meteen, zonder te zoeken in mappen.

Waarom krijgt iedereen een ander resultaat?

Omdat dezelfde prompt niet hetzelfde resultaat geeft. Geef tien mensen dezelfde opdracht en hetzelfde gereedschap en je krijgt tien varianten die ongeveer hetzelfde doen. Claude Code werkt net zo.

Dat is geen fout en het is belangrijk om te weten voor je een tutorial volgt. Wijkt jouw resultaat af van het voorbeeld, dan is dat te verwachten. De vraag is niet of het identiek is, maar of het doet wat je vroeg.

Bevalt een wijziging niet, dan draai je terug. Claude Code houdt bij wat het veranderde, dus je kan naar een eerdere toestand terug zonder zelf bestanden te herstellen. Dat maakt experimenteren goedkoop, en dat is precies de houding die hier werkt.

Hoe zet je een project op dat niet in de war loopt?

Met een vaste mappenstructuur die je in CLAUDE.md beschrijft. Zonder die structuur belandt alles door elkaar in je hoofdmap en wordt het binnen een week onvindbaar. Met die structuur weet Claude waar elk nieuw bestand hoort, zonder dat je het zegt.

Het verschil tussen context en references is subtiel en nuttig. Context gaat over jou en is bedoeld om gelezen en bijgewerkt te worden. References is materiaal waarmee een skill zijn werk doet. Een skill maakt bijvoorbeeld presentaties, en de reference beschrijft hoe een presentatie eruit moet zien.

Wat zet je in CLAUDE.md?

Regels die je anders elke sessie opnieuw zou typen. Claude Code leest dit bestand aan het begin van elke sessie, dus wat erin staat geldt altijd. Deze regels leveren in de praktijk het meeste op.

De laatste regel is voor wie met content werkt de belangrijkste. De voorlaatste scheelt het meeste tijd. En er is nog een regel die je zelf snel toevoegt: gebruik nooit em-dashes. Je corrigeert dat een keer, Claude onthoudt het, en je hoeft het nooit meer te zeggen.

Houd het bestand kort. Claude leest het telkens opnieuw, dus elke regel die erin staat kost je iets. Drie tot vijf harde verboden doen meer dan twintig vriendelijke richtlijnen.

Hoe leert Claude Code wie je bent?

Door je contextmap te vullen, en dat hoef je niet met de hand te doen. Je laat Claude de bronnen doorlopen die je al hebt: je website, je bestanden, je e-mail en je documenten. Daaruit schrijft het bestanden over je bedrijf, je klanten, je cijfers en je schrijfstijl.

De stap die daarna het verschil maakt, is het zelfinterview. Wat Claude niet kon afleiden, zet het in een lijst met openstaande vragen. Laat het je die vragen stellen en beantwoord ze. Dat is een kwartier werk en het is het enige deel van je context dat echt van jou komt.

Het effect merk je pas bij de volgende vraag. Vraag zonder context hoeveel je voor een opdracht moet vragen en je krijgt algemeenheden. Vraag het met context en je krijgt een antwoord dat je eigen eerdere opdrachten, je marge en je markt meeneemt. Dat verschil is de reden om die map te vullen.

Wanneer maak je een skill?

Vanaf de derde keer. Tot twee keer is het sneller om de opdracht gewoon uit te leggen. Vanaf de derde keer verdient het bestand zichzelf terug, want je typt dezelfde veertig berichten niet nog eens.

Een skill is niets meer dan die veertig berichten, een keer opgeschreven. Je beschrijft wat de skill doet, wanneer ze geldt en welke stappen ze volgt. Daarna roep je ze op met een korte opdracht en volgt Claude dezelfde werkwijze als de vorige keer.

Zo bekeken is je werk een stapel skills. De meeste bedrijven draaien op twintig terugkerende taken. Schrijf die een voor een op en je hebt een systeem in plaats van een reeks losse gesprekken.

Wat zijn subagenten en waarom besparen ze geld?

Subagenten zijn extra agenten die een hoofdagent aanstuurt. In plaats van een gesprek dat honderd artikels na elkaar doorneemt, laat je tien agenten elk tien artikels doen. Je ziet alleen het eindresultaat van de hoofdagent, niet de tien onderliggende gesprekken.

De tijdwinst is duidelijk. De besparing die minder bekend is, zit in de tokens. Een gesprek sleept alles mee wat er eerder in gezegd is, dus hoe langer het loopt, hoe duurder elk volgend bericht wordt. Tien korte gesprekken samen kosten minder dan een gesprek dat tien keer zo lang wordt.

Parallel werken loont wanneer de delen onafhankelijk zijn: tien pagina's controleren op dezelfde fout, of tien bronnen samenvatten. Het loont niet wanneer stap twee het resultaat van stap een nodig heeft, want dan sta je alsnog te wachten.

Hoe koppel je Claude Code aan je eigen gereedschap?

Op twee manieren, en het verschil bepaalt waar ze werken. Een MCP-koppeling zet je aan in je instellingen en werkt binnen Claude Code. Een API-sleutel is een wachtwoord dat je in een bestand zet en werkt overal, ook op een website die live staat.

Twee dingen die je anders een uur zoeken kosten. Een MCP-koppeling werkt niet in een gesprek dat al liep voor je ze aanzette, dus begin een nieuw gesprek. En een website die live staat, kan geen MCP gebruiken: wat in Claude Code via MCP werkte, moet je bij publicatie vervangen door een API-sleutel.

Waar bewaar je wachtwoorden en sleutels?

In een apart bestand voor omgevingsvariabelen, nooit in je gewone bestanden en nooit in een gesprek. Dat bestand staat op je computer en wordt bewust niet mee geüpload wanneer je je code online zet.

Dat laatste is geen formaliteit. Er draaien programma's die publieke repositories afspeuren op zoek naar sleutels. Staat er een betaalde sleutel tussen, dan kan iemand anders op jouw rekening werken. Controleer daarom bij elke publicatie of je sleutelbestand echt is uitgesloten.

Een gevolg dat beginners verrast: omdat die sleutels niet mee online gaan, kent je gepubliceerde website ze ook niet. Je moet ze apart toevoegen bij je hostingpartij en daarna opnieuw publiceren. Doe je dat niet, dan werkt je contactformulier lokaal wel en online niet.

Hoe controleer je of iets werkt voor je het oplevert?

Door Claude het te laten testen in plaats van zelf te kijken. Er bestaan hulpmiddelen waarmee Claude je browser bestuurt: het opent je pagina, bekijkt ze op telefoon-, tablet- en bureaubladformaat, maakt schermafbeeldingen en beoordeelt die zelf.

Dat verandert de werkwijze meer dan het klinkt. Zonder die stap stuur je iets op, ontdek jij de fout en ga je terug. Met die stap vindt Claude de fout voor jij het ziet. Zet in je CLAUDE.md dat er niets wordt opgeleverd zonder controle en je verliest die ronde niet meer.

Dezelfde techniek werkt breder dan websites testen. Alles wat in een browser gebeurt en waarvoor geen koppeling bestaat, kan je zo laten uitvoeren. Hou er wel rekening mee dat veel diensten geautomatiseerd gebruik van hun interface niet toestaan, dus lees hun voorwaarden voor je dat inricht.

Hoe zet je het online?

In twee stappen: je code naar een repository, en die repository naar een hostingpartij. Je laat Claude beide stappen doen, maar je moet weten wat er gebeurt om fouten te kunnen plaatsen.

1. Maak een repository aan en zet die op privé. Daar komt je code te staan, en meteen heb je een back-up.
2. Koppel die repository aan je hostingpartij en publiceer.
3. Voeg je sleutels apart toe bij de hostingpartij, want die zijn niet mee geüpload.
4. Publiceer opnieuw, anders kent de live site die sleutels nog niet.
5. Test het formulier op de live site, niet alleen lokaal.

Stap drie en vier zijn waar het bijna altijd misgaat. Het formulier werkt op je eigen computer, je publiceert, en op de live site krijgt een bezoeker een foutmelding. Niet omdat de code fout is, maar omdat de sleutel ontbreekt.

Hoe laat je het werk doorlopen terwijl je slaapt?

Met geplande taken, en met twee regels die je vooraf moet afspreken. Een taak die in de cloud draait, blijft lopen terwijl je computer uit staat, maar heeft geen toegang tot je lokale bestanden. Wil je dat ze je eigen regels of naslagbestanden kan lezen, dan moeten die in de gekoppelde repository staan.

De twee afspraken die je nooit mag overslaan bij werk dat naar buiten gaat:

Die tweede klinkt als een detail en is dat niet. Zonder markering weet een taak die elk uur draait niet wat ze de vorige keer al deed. Een automatisering die zichzelf opnieuw aanroept, stuurt hetzelfde bericht honderd keer voor je het merkt.

Een derde afspraak die erbij hoort: alles wat een taak doet, gebeurt onder jouw naam. Een taak die automatisch op klantmails antwoordt, blijft dat doen terwijl jij op vakantie bent. Bedenk dus per taak wat er gebeurt als je er twee weken niet naar kijkt.

Hoe stook je je limiet niet in een uur op?

Door te weten wat je verbruik opdrijft. Het is verrassend makkelijk om een maandabonnement in een paar uur leeg te trekken, en bijna altijd door een van deze zes dingen.

Dat laatste punt is het meest onderschat. Je verbruik groeit niet lineair met het aantal berichten maar sneller, omdat elk nieuw bericht de hele geschiedenis meeneemt. Een gesprek dat drie uur duurt, kost aan het eind veel meer per antwoord dan aan het begin, ook al stel je dezelfde korte vraag.

Daarom lonen subagenten dubbel en daarom is een nieuw gesprek bij een nieuw onderwerp geen opruimdwang maar een besparing. Controleer af en toe je verbruik, dan weet je waar je staat voor je vastloopt.

Wat leerde ik hiervan op deze website?

Twee dingen die in geen van de twintig handleidingen en video's stonden die ik hiervoor doornam, allebei uit een sessie waarin ik Claude Code alle 297 pagina's van jakency.com liet beoordelen.

Het eerste gaat over waar je controle hoort. Twee pagina's kregen het laagste oordeel en dat bleek fout, niet omdat het model slecht oordeelde maar omdat mijn tekstextractie bij tien pagina's de hoofdinhoud had gemist. Een pagina die 52 woorden leek te hebben, had er 288. Het oordeel klopte met de data die het kreeg. De data klopte niet. Controleer dus je invoer, niet alleen je uitvoer.

Het tweede is bruikbaarder. Omdat elk oordeel een lijst gebreken bevatte, kon ik tellen welk gebrek het vaakst terugkwam. Eenendertig pagina's herhaalden dezelfde definitie woordelijk. Dat bleek één component te zijn die de tekst drie keer afdrukte. Eén reparatie in plaats van eenendertig herschrijvingen.

Dat is het patroon dat Claude Code waardevol maakt en dat zelden in voorbeelden staat: niet dat het sneller schrijft, maar dat het hetzelfde oordeel over honderden items kan vellen zodat je kan tellen. Daar vind je oorzaken in plaats van symptomen.

Waar begin je morgen?

Met één taak die je elke week doet en die je nu met de hand uitvoert. Maak er een map voor, zet er een CLAUDE.md in met vijf regels, doe de taak een keer samen met Claude en maak er daarna een skill van. Dat is een halve dag, en vanaf de derde keer verdien je die terug.

Begin niet met het bouwen van een systeem dat alles doet. Begin met één taak die werkt, want een systeem dat je niet gebruikt is duurder dan geen systeem.

De bredere uitleg over de modellen, de instellingen en het prompten staat bij Claude gebruiken. Een concreet voorbeeld van een koppeling staat bij Google Search Console MCP koppelen aan Claude, en wie dit op WordPress wil toepassen vindt dat bij Claude Code koppelen aan WordPress.