Prompt-engineering cursus voor bedrijven

Prompt-engineering is engineering, geen copywriting

In productie-AI-systemen bepaalt de prompt of een feature werkt of de helpdesk volloopt. Een goede prompt-engineer denkt in system-prompts, few-shot voorbeelden, JSON-schema's, retrieval-context en evals — niet in clevere zinnen voor ChatGPT. Onze cursus leert technische teams hoe ze prompts ontwerpen, versionen, testen en monitoren als onderdeel van een serieuze software-stack.

System-prompt architectuur Function-calling RAG-prompting Evals & LLM-as-judge Prompt-injection defense

Bespreek een in-house cursus Bekijk curriculum

Voor wie is deze cursus bedoeld

Geen "leer ChatGPT-prompts schrijven"-workshop. Dit is een technische training voor teams die LLM's in productie hebben of binnenkort gaan deployen — met alle versionering-, eval- en monitoring-issues die daarbij horen.

De cursus is opgezet voor developers, data-engineers, ML-engineers, content-teams die met structured generation werken en customer-service-leads die LLM-bots aansturen. Voorkennis: deelnemers werken al met een LLM-API (OpenAI, Anthropic, Azure OpenAI of een open-source model via vLLM/Ollama), kennen het verschil tussen een chat completion en een completion endpoint, en hebben minimaal een keer een feature gebouwd waarin een LLM in een request-response-cyclus zit. We gaan voorbij de basis: function-calling, JSON-mode, schema-constrained decoding, RAG-pipelines en multi-agent handoffs zijn de standaard.

Wat we nadrukkelijk níet doen: prompt-tips delen die je ook op LinkedIn vindt, "act as a senior consultant"-hacks oefenen, of beweren dat een goede prompt alle LLM-problemen oplost. We behandelen prompt-engineering als één laag in een groter AI-systeem — naast model-keuze, retriever-tuning, guardrails en monitoring. Wie alleen wil leren hoe je een betere ChatGPT-prompt schrijft, is hier verkeerd; daar zijn andere cursussen voor.

AI-ontwikkeling AI-chatbot voor bedrijven Enterprise AI-implementatie AI-discovery workshop

Curriculum: vijf modules, opbouwend

De cursus loopt van prompt-architectuur naar agent-orchestration. Elke module combineert theorie met hands-on opdrachten op de eigen use cases van de deelnemers — geen toy-voorbeelden, geen verzonnen tasks.

Prompt-architectuur

Hoe je een prompt opbouwt voor productie: het verschil tussen system- en user-prompt, role-based prompting, context-management bij lange dialogen, en wanneer je context juist moet truncaten of samenvatten. We behandelen prompt-componenten — instructies, context, voorbeelden, schema's, output-format — en hoe je ze in een herbruikbaar template-systeem giet zodat developers niet elke prompt opnieuw uitvinden.

System- versus user-prompt: wat hoort waar
Role-based prompting en persona-stabiliteit
Context-window management en token-budgetten
Prompt-templates en variabel-substitutie zonder injectie-risico

Few-shot, zero-shot, chain-of-thought en ReAct

Wanneer kies je welke aanpak? Few-shot werkt voor classificatie en gestructureerde extractie, maar kost tokens; chain-of-thought verbetert redeneer-taken maar verhoogt latency; ReAct is krachtig voor agent-loops maar onstabiel zonder strakke schema-controle. We bouwen alle vier en meten ze tegen elkaar af op een echte taak.

Few-shot example selection en in-context learning
Chain-of-thought (CoT) prompting en self-consistency
ReAct: reasoning + acting in één loop
Trade-offs tussen accuracy, latency en kosten

Function-calling, tool-use en structured output

Een productie-LLM produceert geen vrije tekst maar een gevalideerd JSON-object dat je downstream kunt gebruiken. We behandelen function-calling (OpenAI, Anthropic), tool-use met een tool-router, JSON-mode, en schema-constrained decoding via libraries zoals Outlines of Instructor. Inclusief retry-logic bij invalid outputs en hoe je voorkomt dat het model halve tool-calls uitspuugt.

Function-calling spec en tool-routing patterns
JSON-mode versus schema-constrained decoding
Pydantic / Zod schema's als single source of truth
Validatie, retries en fallback-strategieën

Guardrails, jailbreak-prevention en prompt-injection

Elk LLM-systeem dat user-input verwerkt is een aanvalsoppervlak. We behandelen prompt-injection (direct en indirect, bijvoorbeeld via opgehaalde RAG-documenten), jailbreak-patronen en de bekende defenses: input-sanitisatie, sandwich-prompting, output-filtering, en het scheiden van trusted en untrusted context. Inclusief praktische demo's met actuele jailbreaks en hoe je ze blokkeert zonder je legitieme use case te slopen.

Direct en indirect prompt-injection
Jailbreak-categorieen en mitigatie-patronen
Output-filtering en content-moderatie
Trusted vs untrusted context-scheiding

RAG-prompting, agent-prompting en multi-agent handoffs

Retrieval-augmented generation klinkt simpel — gooi documenten in de context — maar in productie zit alle complexiteit in het prompten: hoe instrueer je het model om alleen geciteerde feiten te gebruiken, hoe ga je om met conflicterende bronnen, en hoe voorkom je dat de retriever-noise het model verwart. Daarna bouwen we een agent-loop met tool-use en behandelen we multi-agent handoffs: wanneer geeft agent A het stokje aan B, en hoe persistent maak je de gedeelde state.

RAG-prompts: citation-enforcement en source-grounding
Retriever-output integreren zonder hallucinatie
Agent-loops: planning, action, observation
Multi-agent handoffs en gedeelde memory

Evals: hoe weet je dat een prompt werkt

Een prompt die "goed voelt" tijdens development is geen prompt die werkt in productie. Evals zijn de unit-tests van AI-systemen: zonder evals weet je niet of je nieuwe prompt-versie beter of slechter is dan de vorige. Deze module behandelt eval-frameworks en hoe je ze inbouwt in je CI-pipeline.

Promptfoo

Open-source CLI voor prompt-testing. Definieer test-cases in YAML, draai ze tegen meerdere modellen, vergelijk outputs side-by-side. Geschikt voor regression-testing van prompt-changes in CI. Werkt goed voor structured-output use cases waarbij je per case een verwachte JSON kunt definieren.

Langfuse

Tracing en eval-platform voor LLM-apps. Logt elke call (prompt, response, latency, kosten) en laat je evals draaien op productie-traces. Open-source, self-hostable — belangrijk voor teams met EU-residency-eisen. Integreert met LangChain, LlamaIndex en raw OpenAI/Anthropic SDK's.

Helicone

Observability-laag die je tussen je app en de LLM-API zet. Geeft per request inzicht in latency, kosten, cache-hits en error-rates. Combineert goed met Promptfoo of Langfuse: Helicone voor productie-telemetrie, Promptfoo voor offline regression.

Custom evals: LLM-as-judge

Voor open-ended outputs werkt een keyword-match niet. LLM-as-judge gebruikt een sterk model om een ander model's output te scoren op rubrics (correctheid, toon, format-naleving). We behandelen judge-bias, calibration en hoe je voorkomt dat je judge dezelfde fouten maakt als je productie-model.

Golden datasets

Eval-quality is dataset-quality. We leren deelnemers hoe ze een golden dataset opbouwen uit echte productie-interacties: edge-cases, regressie-cases, adversarial inputs. Inclusief annotation-workflows en hoe je dataset-drift detecteert.

A/B-testing in productie

Offline evals dekken niet alles. We behandelen feature-flags voor prompt-versies, traffic-splitting per user-cohort, en hoe je een statistisch significante prompt-uplift meet zonder je users te schaden bij een slechte variant.

Productie-issues die je nergens anders leert

Een werkende prompt op je laptop is niet hetzelfde als een prompt die zes maanden lang stabiel draait. Deze module behandelt de operationele realiteit: versionering, drift, kosten en caching.

Prompt-versionering is geen optie maar een verplichting. Elke prompt die productie raakt krijgt een versie-nummer, een changelog en een rollback-pad — net als code. Wij behandelen prompt-versionering in Git (prompts-as-code), in een prompt-management-tool (Langfuse, PromptLayer) en hybride modellen waarbij prompts in een database leven met audit-trail.

Drift-monitoring is het tweede stuk. Een prompt die vandaag werkt, kan over drie maanden slechter presteren omdat het onderliggende model is geupdate (silent model-updates bij de API-providers), omdat de input-distributie is verschoven, of omdat een upstream-systeem zijn output-format heeft veranderd. We behandelen drift-detectie via continue evals op een vaste set, semantic similarity-checks op outputs en alerting bij score-degradatie.

Kosten-optimalisatie is het derde. Naive LLM-implementaties kunnen veel duurder zijn dan nodig. We behandelen prompt-caching (Anthropic prompt-caching, OpenAI's automatic caching, Redis-based response-caching), model routing (cheap model voor simpele queries, sterk model voor complexe), batch-processing voor async workloads, en hoe je een kosten-budget per request afdwingt zonder je service te slopen bij piekgebruik.

Tot slot: de praktische dingen waar niemand ooit over schrijft. Hoe ga je om met rate-limits van providers (exponential backoff, request-queueing, multi-provider fallback)? Hoe debug je een prompt die "soms" faalt? Hoe rol je een prompt-update uit zonder downtime? En hoe leg je aan compliance uit dat je geen verzonnen content genereert maar een gegrond antwoord uit je RAG-pipeline?

Hands-on: deelnemers werken op eigen use cases

De cursus is geen serie van slides. Elke module heeft hands-on opdrachten waarin deelnemers prompts schrijven, evalueren en herzien op hun eigen productie-use cases. Geen abstracte oefeningen — de prompt die je in de cursus bouwt, kun je vrijdag deployen.

CRM-AI: lead-enrichment en classificatie

Een veelvoorkomende use case: het CRM-systeem moet inkomende leads automatisch classificeren, verrijken met openbare data en doorzetten naar de juiste sales-rep. Deelnemers bouwen een function-calling prompt met JSON-schema, een retry-loop voor invalid outputs, en evals op een dataset van historische leads. Inclusief edge-case handling (incomplete data, multi-language input, ambigue cases).

Klantenservice-bot met RAG

Een KS-bot die antwoorden put uit een knowledge-base: handleidingen, FAQ's, beleidsdocumenten. Deelnemers ontwerpen de RAG-prompt (citation-enforcement, fall-back bij geen match, escalatie naar mens), bouwen een eval-set met edge-cases en testen prompt-injection-resistence met adversarial inputs.

Intern-wiki RAG voor engineering-teams

Een tweede RAG-case: een Q&A-systeem dat in interne documentatie zoekt — Confluence, Notion, Google Docs. Andere uitdagingen dan klantenservice: meer technisch jargon, code-snippets in de retrieval, multi-document antwoorden, en ACL-respect (welke gebruiker mag welke docs zien). Deelnemers bouwen een prompt die uitsluitend uit toegestane bronnen put.

Document-extractie pipeline

Gestructureerde data extraheren uit PDF's, contracten of formulieren met function-calling en schema-constrained decoding. Deelnemers definieren een Pydantic-schema, schrijven de extractie-prompt, bouwen retries voor parse-failures en meten extractie-accuracy tegen een handmatig gelabelde set.

Wie geen eigen use case heeft, krijgt een realistische case-study aangereikt — bijvoorbeeld een document-extractie-pipeline op publiek beschikbare contracten, of een RAG-bot op open-source documentatie. Maar de meeste teams komen met meerdere productie-cases die ze in de cursus willen aanvliegen.

Tools en frameworks die we behandelen

De cursus is provider-agnostisch in de basisconcepten, maar we werken in de hands-on met de tools die in productie het meest voorkomen. Deelnemers krijgen praktische ervaring met meerdere modellen en frameworks zodat ze weloverwogen keuzes kunnen maken — niet alleen "wat we toevallig kennen".

OpenAI GPT-4o / GPT-4-turbo Anthropic Claude Azure OpenAI Google Gemini Mistral Ollama / vLLM (local) LangChain LlamaIndex LiteLLM Instructor Outlines Pydantic Promptfoo Langfuse Helicone PromptLayer Weights & Biases Weave Pinecone / Qdrant / pgvector

Belangrijk: we leren deelnemers waarom een tool past bij een use case, niet om elke tool een naam-droppen. LangChain is krachtig maar overkill voor simpele apps; LiteLLM is een dunne abstractie voor multi-provider routing; Instructor is mooi voor schema-constrained extractie maar voegt een laag toe. Welke combinatie past bij jouw stack hangt af van team-skills, deploy-omgeving en data-residency-eisen — daar leiden we deelnemers doorheen.

AI-ontwikkeling op maat AI-documentverwerking AI-klantenservice automatisering Custom software

Case-walkthrough: van naive prompt naar productie-grade

Een typisch oefenpatroon uit de cursus, beknopt: hoe een quote-extractie-prompt evolueert van een 200-token zero-shot poging naar een geinstrumenteerde pipeline met evals, caching en monitoring.

Iteratie 1 — Naive zero-shot

Een developer schrijft een prompt: "Extract the customer name, order ID and total amount from this email." Werkt op een deel van de inputs. Op de overige extraheert het model verkeerde velden, hallucineert IDs of weigert te antwoorden bij meertalige e-mails. Geen schema, geen retries, geen evals.

Iteratie 2 — Few-shot met JSON-schema

Toevoegen: enkele few-shot voorbeelden die diversiteit dekken (Engels, Nederlands, met BTW, zonder BTW), function-calling met een Pydantic-schema dat customer_name, order_id en total_amount_eur als strict-typed velden definieert. Accuracy verbetert duidelijk, maar de kosten verdubbelen door de extra context-tokens, en bij rare formats levert het model nog steeds invalid JSON.

Iteratie 3 — Schema-constrained decoding + retry

Vervangen door schema-constrained decoding via Instructor: het model kan structureel geen invalid JSON meer produceren. Retry-logic met exponential backoff bij parse-failures. Eval-set in Promptfoo om elke prompt-wijziging meetbaar te maken. Latency stijgt nauwelijks.

Iteratie 4 — Productie-instrumentatie

Langfuse logt elke call met prompt-versie, kosten en latency. Helicone cachet vergelijkbare requests (identieke e-mail-templates leveren cache-hits). A/B-test in productie tussen twee prompt-versies (extra disambiguation-instructie voor bedragen in valuta's anders dan EUR). Drift-eval draait elke nacht op nieuwe productie-traces om regressie te detecteren.

Wat je leert van deze flow

Begin nooit met een complexe prompt — meet eerst de baseline.
Schema-constrained decoding lost een hele klasse problemen op die met retries niet weg te krijgen zijn.
Evals zijn de blocker: zonder eval-set kun je iteratie 1 niet van iteratie 4 onderscheiden.
Caching is gratis kostenbesparing zodra je hetzelfde model meerdere keren met vergelijkbare input aanroept.
Een prompt is nooit "af" — drift-monitoring vangt de regressies op die je in dev nooit ziet.

Plan een intake-gesprek AI-consultant inhuren Enterprise AI-implementatie

Veelgestelde vragen over de prompt-engineering cursus

Welke voorkennis wordt verwacht van deelnemers?

Deelnemers hebben minimaal een keer een feature gebouwd waarin een LLM via API werd aangeroepen, kennen het verschil tussen system- en user-prompts, en hebben Python- of TypeScript-fluency. Deze cursus is niet voor beginners — wie net wil leren wat een prompt is, raden we eerst een algemene LLM-introductie aan. Wij behandelen function-calling, JSON-mode en RAG vanaf dag een als gegeven.

Wat is het verschil tussen prompt-engineering en fine-tuning?

Prompt-engineering past het gedrag van een algemeen model aan via instructies, voorbeelden en context — zonder de modelgewichten te wijzigen. Fine-tuning past de gewichten aan op een trainings-dataset. Voor de meeste productie-use cases is prompt-engineering met RAG voldoende; fine-tuning is pas relevant bij specifieke style-transfer, hoge-volume cost-optimalisatie of taken die de basis-prompt-architectuur niet kan oplossen. We behandelen wanneer welk gereedschap de juiste keuze is.

Werken we met OpenAI, Anthropic of open-source modellen?

Met meerdere. De concepten zijn provider-agnostisch, maar de syntax verschilt — function-calling bij OpenAI is anders dan tool-use bij Anthropic, en open-source modellen via vLLM of Ollama hebben weer andere quirks. Deelnemers krijgen ervaring met minimaal twee providers en doen tenminste een opdracht op een lokaal draaiend model voor data-residency-cases.

Hoe gaan jullie om met EU-residency en privacy-eisen?

We behandelen verschillende deployment-modellen: API-providers met EU-datacenters (Azure OpenAI EU, Anthropic via AWS Bedrock EU), self-hosted open-source modellen via vLLM of Ollama, en hybride architecturen waarbij gevoelige extractie lokaal gebeurt en alleen geanonimiseerde context naar een externe API gaat. Welk model past, hangt af van de juridische context van de opdrachtgever.

Hoe lang duurt de cursus en hoe wordt die geleverd?

De standaard-opzet is meerdere dagen verspreid over twee tot drie weken — een dag theorie en concepten, gevolgd door hands-on dagen met de eigen use cases. Tussen de dagen werken deelnemers aan opdrachten op hun eigen codebase. We leveren in-house op locatie, online via remote-pairing of hybride. De exacte planning stemmen we af op de teamsamenstelling en bestaande projecten.

Wat bepaalt de investering voor een in-house cursus?

De investering hangt af van het aantal deelnemers, de mate van customization op de eigen use cases en of we naast de cursus ook hands-on meebouwen aan productie-prompts. Een standaard-curriculum voor een team is anders dan een cursus waarin we ook de bestaande prompt-stack auditten en herstructureren. We maken vooraf een offerte op basis van scope.

Bieden jullie ook ondersteuning na de cursus?

Ja, voor teams die dat willen. Mogelijke vormen: een follow-up review na enkele weken waarin we de prompts beoordelen die teams na de cursus in productie hebben gezet, een doorlopend prompt-engineering retainer, of een hands-on bouwopdracht waarbij wij naast het team meebouwen aan de eerste productie-feature. De cursus zelf is geen black-box afsluiter maar het begin van een werkrelatie als dat past.

Hoe verhoudt deze cursus zich tot een AI-discovery workshop?

Een AI-discovery workshop is strategisch: welke AI-use cases passen bij ons bedrijf, wat is de roadmap, waar zit de business value. Deze prompt-engineering cursus is technisch en uitvoerend: hoe bouw je de prompts die in die use cases worden gebruikt. Veel klanten doen eerst de discovery-workshop met decision-makers en daarna de prompt-engineering cursus met het uitvoerende team.

Prompt-engineering cursus voor uw team plannen?

Vertel ons welke LLM-features u in productie heeft of wilt bouwen, met welk team-niveau u start en welke deployment-omgeving u gebruikt. We stellen een curriculum samen dat past bij uw stack en use cases — geen template, geen generieke slides.

Plan een intake-gesprek