Prompt Engineering

De bottleneck bij software bouwen is verschoven. Het probleem is niet langer “ik kan niet programmeren.” Het probleem is: “ik kan niet helder uitleggen wat ik wil.”

AI-modellen zijn spectaculair goed geworden in het genereren van code. Maar ze zijn volledig afhankelijk van jouw instructies. Geef een vaag verzoek, en je krijgt vage code. Geef een gestructureerde, specifieke prompt, en je krijgt code die doet wat je bedoelt — op de manier die je bedoelt.

Prompt engineering is geen mysterieuze kunst. Het is een vaardigheid die je kunt leren. In deze module ontleden we de anatomie van een goede prompt, leer je acht patronen die je dagelijks kunt inzetten, en ontdek je hoe je de AI effectief bijstuurt wanneer het resultaat niet klopt.

Of je nu een ondernemer bent die een MVP bouwt of een developer die sneller wil werken: de principes zijn hetzelfde. Wie beter leert communiceren met AI, bouwt betere software.

Elke effectieve prompt bevat — bewust of onbewust — een combinatie van vijf elementen. Hoe meer bouwstenen je expliciet meeneemt, hoe beter het resultaat.

1. Context

Geef de AI achtergrond over je project, de gebruikte technologie en de bestaande codebase. Zonder context maakt de AI aannames die vaak verkeerd zijn.

2. Taak

Beschrijf concreet wat de AI moet doen. Gebruik werkwoorden: maak, voeg toe, refactor, los op, test. Vermijd abstracte beschrijvingen.

3. Richtlijnen

Geef aan welke conventies, patronen of stijlen je wilt volgen. Dit voorkomt dat de AI eigen keuzes maakt die niet passen bij je project.

4. Beperkingen

Vertel de AI wat het niet moet doen. Beperkingen zijn minstens zo belangrijk als instructies. Ze voorkomen dat de AI te veel doet, verkeerde bibliotheken kiest, of bestaande code breekt.

5. Output-formaat

Geef aan hoe je het resultaat wilt ontvangen. Wil je een volledig bestand? Alleen het verschil? Een stap-voor-stap uitleg? Het formaat bepaalt de bruikbaarheid van het antwoord.

AI-modellen hebben een contextvenster: een maximale hoeveelheid tekst die ze tegelijk kunnen verwerken. Hoe groter je project wordt, hoe belangrijker het is om slim met die ruimte om te gaan. Drie strategieën helpen je daarbij.

Rules files: je project op papier

Leg de kernregels van je project vast in een bestand dat de AI altijd meeleest. Tools als Cursor (.cursorrules), Claude (CLAUDE.md) en Windsurf (.windsurfrules) ondersteunen dit. Beschrijf hierin je techstack, naamconventies, mappenstructuur en veelgemaakte fouten.

Dit bespaart je tientallen herhaalde instructies per sessie. De AI “onthoudt” je projectregels zonder dat je ze elke keer opnieuw hoeft te typen.

Context layering: geef alleen wat relevant is

Stuur niet je hele codebase mee. Selecteer de bestanden die direct relevant zijn voor je vraag. Werk in lagen: begin met het bestand dat je wilt wijzigen, voeg gerelateerde types en interfaces toe, en verwijs naar patronen die elders in het project worden gebruikt.

Hoe gerichter de context, hoe beter het antwoord. Een AI die drie relevante bestanden ziet presteert beter dan een die honderd bestanden moet doorzoeken.

Nieuwe gesprekken: de reset-knop

Start een nieuw gesprek wanneer je van onderwerp wisselt. Een lang gesprek over authenticatie dat overgaat in styling en vervolgens in database-optimalisatie verliest focus. De AI raakt in de war over wat er nu eigenlijk gevraagd wordt.

Een nieuw gesprek met een heldere openingsprompt is bijna altijd beter dan doormodderen in een vervuild gesprek.

De eerste reactie van de AI is zelden perfect. Dat is normaal. Het echte werk zit in het bijsturen. Er zijn drie niveaus van feedback, elk met een andere intensiteit.

Richting bijsturen

Het resultaat is in de goede richting, maar mist details of maakt verkeerde aannames. Je geeft kleine correcties: “Gebruik een dropdown in plaats van radiobuttons”, “Voeg validatie toe op het e-mailveld”, “De foutmelding moet in het Nederlands.”

Dit is het mildste niveau. Je bouwt voort op wat de AI al heeft gemaakt.

Aanpak corrigeren

De AI heeft een fundamenteel verkeerde aanpak gekozen. Misschien gebruikt het client-side rendering waar server-side beter past, of kiest het een bibliotheek die je niet wilt gebruiken.

Hier geef je duidelijk aan wat er mis is met de gekozen aanpak en beschrijf je de gewenste richting: “Dit moet een Server Component zijn, geen Client Component. Haal de data op met een server-side fetch in plaats van useEffect.”

Terugdraaien en opnieuw beginnen

Soms is het sneller om opnieuw te beginnen dan om een verkeerd resultaat te repareren. Herken dit moment. Als je merkt dat je meer tijd besteedt aan het corrigeren dan aan het bouwen, is een nieuwe prompt met betere instructies effectiever.

Gebruik wat je hebt geleerd van de eerste poging om de tweede prompt scherper te maken. Omschrijf expliciet wat er de vorige keer misging.

Debuggen is een van de krachtigste toepassingen van AI. Maar de manier waarop je een bug presenteert, bepaalt of je een werkende fix krijgt of een reeks zinloze suggesties. Volg deze vier stappen.

Stap 1: Beschrijf het verwachte gedrag

Begin altijd met wat er zou moeten gebeuren: “Wanneer een gebruiker op 'Opslaan' klikt, moet het formulier naar de server worden verstuurd en moet de gebruiker een bevestigingsmelding zien.”

Stap 2: Beschrijf het werkelijke gedrag

Beschrijf concreet wat er in plaats daarvan gebeurt: “De pagina herlaadt volledig, de data wordt niet opgeslagen, en er verschijnt geen foutmelding.”

Stap 3: Deel de foutmelding en relevante code

Kopieer de volledige foutmelding, inclusief de stacktrace. Voeg de code toe die het probleem veroorzaakt. Meer context is beter: de AI kan niet raden wat er in bestanden staat die je niet deelt.

Stap 4: Vraag om uitleg, niet alleen een fix

Voeg toe: “Leg uit waarom deze fout optreedt voordat je een oplossing geeft.” Dit dwingt de AI om het probleem te analyseren in plaats van blind code aan te passen. Je leert ervan en kunt beoordelen of de fix logisch is.

Error-forward prompting: plak de foutmelding letterlijk in je volgende bericht. Dit is de snelste manier om te debuggen. De AI herkent bekende foutpatronen en kan vaak in één keer de juiste oplossing geven.

Zodra je de basis beheerst, zijn er drie geavanceerde technieken die je resultaten naar een hoger niveau tillen.

Multi-agent workflows

Gebruik verschillende AI-gesprekken voor verschillende rollen. Eén gesprek plant de architectuur, een ander schrijft de code, een derde reviewt het resultaat. Door de AI steeds een specifieke rol te geven — “je bent een security-expert” of “je bent een database-architect” — krijg je diepere, meer gespecialiseerde antwoorden.

Dit simuleert een team van specialisten. De planner denkt in structuur, de bouwer in implementatie, de reviewer in risico's. Elk perspectief vangt blinde vlekken van de ander.

Constraint anchoring

Zet je beperkingen aan het begin van de prompt, niet aan het einde. AI-modellen geven meer gewicht aan instructies die vroeg in de prompt staan. Begin met: “Gebruik uitsluitend TypeScript strict mode. Geen any types. Geen externe dependencies.” en geef daarna pas de taak.

Dit principe werkt ook bij langere prompts: plaats de belangrijkste regels bovenaan en herhaal ze eventueel onderaan als samenvatting.

Voorbeeldgestuurd prompten

Geef de AI een voorbeeld van het gewenste resultaat. In plaats van te beschrijven hoe een API-route eruit moet zien, plak je een bestaande route uit je project en zeg: “Maak een nieuwe route voor [feature] die dezelfde structuur volgt als dit voorbeeld.”

Voorbeelden zijn krachtiger dan beschrijvingen. De AI pikt naamconventies, foutafhandeling, import-structuur en stijl automatisch op uit het voorbeeld. Dit is de meest betrouwbare manier om consistentie te waarborgen.

Zes sjabloonprompts die je direct kunt gebruiken. Pas de tekst tussen vierkante haken aan voor je eigen situatie.

Projectstart

Nieuwe feature

Bug fix

Code review

Refactoring

Deployment check