5 lessen na 6 maanden dagelijks werken met Claude Code

Zes maanden geleden begon ik met Claude Code. Ik was sceptisch – weer een AI tool die belooft dat het je werk makkelijker maakt. Maar ik besloot het een kans te geven. Inmiddels gebruik ik het dagelijks. Hier zijn vijf dingen die ik geleerd heb.

Les 1: Het is geen autopilot

Dit is misschien wel de belangrijkste les. Claude Code is geen magische knop die al je werk doet. Het is een tool, en zoals elke tool moet je leren hoe je het goed gebruikt.

In het begin deed ik dit:

```

Bouw een complete e-commerce site met user auth, product catalog, shopping cart en checkout.

```

Het resultaat was... oké. Maar niet goed. De structuur was rommelig, de code was niet consistent, en er zaten bugs in.

Nu doe ik het anders:

```

Maak een basis Express server met user routes

-> test dit

Voeg JWT authenticatie toe aan de user routes

-> test dit

Maak product routes met CRUD operaties

-> test dit

```

Kleine stappen, testen tussen elke stap. Dat werkt veel beter.

Wat ik hiervan leerde: Gebruik het als een pair programmer, niet als een ghostwriter. Jij blijft de lead developer.

Les 2: Context is alles

Claude Code werkt het beste als het begrijpt wat je probeert te doen. Niet alleen de technische opdracht, maar ook de context eromheen.

Slecht voorbeeld:

```

Fix deze functie

```

Beter:

```

Deze functie fetchet user data maar crashed soms. Ik denk dat het komt door een race condition wanneer meerdere requests tegelijk gebeuren. Kun je een check toevoegen en de functie thread-safe maken?

```

Het verschil is enorm. In het eerste geval gaat Claude gokken. In het tweede geval begrijpt het het probleem en komt met een betere oplossing.

Wat ik hiervan leerde: Neem de tijd om je vraag goed te formuleren. 30 seconden extra typing bespaart 10 minuten debugging.

Les 3: Het maakt fouten (en dat is oké)

Claude Code is niet perfect. Het maakt fouten. Soms zijn het kleine dingen zoals een ontbrekende import. Soms zijn het fundamentele ontwerpkeuzes die niet kloppen.

Een voorbeeld uit mijn eigen werk: ik vroeg het om een caching layer toe te voegen aan een API. Het gebruikte een in-memory cache. Technisch correct, maar voor mijn use case (multiple servers achter een load balancer) was Redis een betere keuze.

Waarom gebeurt dit? Omdat AI modellen werken met patronen. Als veel voorbeelden in-memory caching gebruiken, is dat wat het suggereert. Het kent jouw specifieke situatie niet.

Wat ik hiervan leerde:

- Review alles wat het maakt - Test grondig - Vraag jezelf af: "Is dit de beste oplossing voor MIjN situatie?"

Het is geen teken van falen als je code moet aanpassen. Het is deel van het proces.

Les 4: Sommige dingen doe je beter zelf

Na zes maanden heb ik een goed gevoel voor wat ik wel en niet aan Claude Code vraag.

Goed voor Claude Code:

- Boilerplate code (API routes, models, schemas) - Tests schrijven - Documentatie - Refactoring (vooral grote, mechanische veranderingen) - Code uitleggen/leren

Beter zelf doen:

- Complex business logic - Performance-critical code - Security-gevoelige features - Architectuur beslissingen

Waarom? Omdat dit dingen zijn waar context en nuance belangrijk zijn. Claude Code kan je helpen, maar de beslissingen moet je zelf maken.

Voorbeeld: Voor een recent project moest ik beslissen hoe we user permissions gingen opslaan. Ik vroeg Claude Code om de opties uit te leggen (role-based vs attribute-based access control). Dat was super nuttig. Maar de uiteindelijke keuze – gebaseerd op onze specifieke use case en toekomstige plannen – die maakte ik zelf.

Wat ik hiervan leerde: Gebruik het voor wat het goed in is. Voor de rest ben jij nog steeds de expert.

Les 5: Het verandert hoe je werkt (op een goede manier)

Dit is minder tastbaar, maar wel belangrijk. Claude Code heeft de manier waarop ik werk veranderd.

Voor Claude Code:

- Idea -> Google -> Stack Overflow -> Documentatie -> Code -> Test - Veel context switching - Veel tijd aan boilerplate

Met Claude Code:

- Idea -> Beschrijf aan Claude -> Review code -> Pas aan -> Test - Blijf in de flow - Focus op de interessante problemen

Een concreet voorbeeld: vorige week moest ik een GraphQL API bouwen. Normaal zou ik een tutorial volgen, voorbeeldcode kopiëren, aanpassen, debuggen. Nu beschreef ik wat ik wilde, kreeg een basis implementatie, en kon meteen focussen op de schema design en resolvers – de delen waar ik echt waarde toevoeg.

Resultaat: wat normaal een dag werk was, deed ik in 3 uur.

Maar er is ook een keerzijde: ik merk dat ik minder vaak de documentatie lees. Soms is dat prima, maar soms mis je daardoor nuances. Ik probeer daar bewust mee om te gaan door regelmatig "naar de bron" te gaan, vooral voor nieuwe libraries.

Wat ik hiervan leerde: Embrace de nieuwe workflow, maar blijf ook bewust leren buiten Claude Code om.

Bonus les: Het wordt steeds beter

Een ding dat ik heb gemerkt: de modellen worden steeds beter. Dingen die zes maanden geleden niet werkten, werken nu wel. Patronen die het toen niet herkende, herkent het nu zonder problemen.

Dit is zowel cool als iets om rekening mee te houden. Cool omdat het betekent dat de tool steeds nuttiger wordt. Iets om rekening mee te houden omdat het betekent dat je aannames over wat het wel/niet kan regelmatig moet bijstellen.

Conclusie

Na zes maanden kan ik zeggen: Claude Code is een waardevol deel van mijn toolkit geworden. Het is niet perfect, het vervangt me niet, maar het maakt me wel productiever.

De belangrijkste dingen om te onthouden:

1. Gebruik het als tool, niet als vervanging

2. Geef goede context

3. Review en test alles

4. Ken de grenzen

5. Embrace de nieuwe workflow

Als je er nog niet mee werkt en je bent benieuwd: probeer het gewoon. Start klein, experimenteer, en bouw het langzaam in je workflow. Het is een leercurve, maar voor mij was het het meer dan waard.

Wil je meer leren over hoe ik Claude Code in mijn dagelijkse werk gebruik? Schrijf je in voor de nieuwsbrief. Ik deel elke week praktische tips en binnenkort organiseer ik gratis webinars waarin ik live laat zien hoe ik ermee werk.