AI Prompt Engineering: Essentiële Commando's en Technieken voor Ontwikkelaars

Prompt engineering is naar voren gekomen als een van de belangrijkste vaardigheden voor ontwikkelaars die werken met AI tools. Of je nu ChatGPT, Claude, GitHub Copilot of Cursor gebruikt, de kwaliteit van je prompts bepaalt direct de kwaliteit van de AI-output. Een goed opgestelde prompt kan een vage, onbruikbare reactie transformeren tot nauwkeurige, productie-klare code. Deze uitgebreide gids behandelt alles van fundamentele prompting technieken tot geavanceerde strategieën, tool-specifieke tips en kant-en-klare templates die je helpen het maximale uit elke AI-interactie te halen.

Wat is Prompt Engineering?

Prompt engineering is de kunst en wetenschap van het opstellen van effectieve instructies voor AI taalmodellen om de gewenste output te produceren. In de kern gaat het over communicatie — leren hoe je de taal spreekt die AI modellen het beste begrijpen. Net zoals een senior ontwikkelaar nauwkeurigere instructies geeft aan een junior ontwikkelaar om betere resultaten te krijgen, leert prompt engineering je hoe je je intentie aan AI systemen communiceert met helderheid en precisie.

Voor ontwikkelaars is prompt engineering belangrijk omdat AI coding assistants een integraal onderdeel zijn geworden van moderne ontwikkelworkflows. Deze tools kunnen code genereren, problemen debuggen, tests schrijven, architecturen refactoren en complexe systemen uitleggen — maar alleen wanneer ze de juiste instructies krijgen. Een slecht geschreven prompt kan code opleveren die compileert maar niet overeenkomt met je intentie, de verkeerde framework versie gebruikt, of kritieke edge cases negeert. Een goed doordachte prompt kan daarentegen code opleveren die niet te onderscheiden is van wat een ervaren ontwikkelaar zou schrijven.

De impact van kleine promptwijzigingen is dramatisch. Beschouw het verschil tussen "fix de bug" en "fix de null reference exception in de UserService.authenticate methode die optreedt wanneer de email parameter undefined is. De methode staat in src/services/UserService.ts en gebruikt bcrypt voor wachtwoordvergelijking." De eerste prompt geeft de AI vrijwel niets om mee te werken. De tweede biedt een duidelijke probleembeschrijving, locatie en context — waardoor de AI een nauwkeurige, correcte fix kan leveren bij de eerste poging.

Fundamentele Prompting Technieken

Begrip van de kern prompting technieken geeft je een fundament om op voort te bouwen. Elke techniek heeft specifieke gebruikssituaties waarin hij uitblinkt, en ervaren prompt engineers combineren vaak meerdere technieken in een enkele prompt voor maximale effectiviteit.

Zero-Shot Prompting

Zero-shot prompting is de eenvoudigste vorm van prompting — je geeft de AI een directe instructie zonder voorbeelden te geven. De AI leunt volledig op zijn trainingsdata en de informatie in je prompt om een reactie te genereren. Deze techniek werkt goed voor eenvoudige taken waarbij het gewenste outputformaat duidelijk is of waarbij de AI veel vergelijkbare voorbeelden heeft gezien tijdens training.

Write a Python function that validates an email address using regex.
The function should return True for valid emails and False for invalid ones.

Zero-shot prompting is effectief voor veelvoorkomende, goed gedefinieerde taken. Echter, wanneer je een specifiek outputformaat, stijl of benadering nodig hebt die afwijkt van het meest voorkomende patroon, wordt few-shot prompting betrouwbaarder.

Few-Shot Prompting

Few-shot prompting houdt in dat je een of meer voorbeelden geeft van het gewenste input-output patroon voordat je de daadwerkelijke taak geeft. Deze techniek is krachtig omdat het precies demonstreert wat je wilt, waardoor ambiguïteit wordt verminderd en de AI wordt geleid naar het juiste formaat en de juiste stijl. De AI leert het patroon uit je voorbeelden en past het toe op de nieuwe input.

Convert these database column names to camelCase JavaScript variable names:

user_first_name -> userFirstName
created_at_timestamp -> createdAtTimestamp
is_email_verified -> isEmailVerified
total_order_count ->

Now convert: product_category_id

Few-shot prompting is bijzonder waardevol wanneer je consistente opmaak, specifieke codeerconventies nodig hebt, of wanneer de AI anders aannames zou kunnen doen die niet overeenkomen met de stijl van je project. Twee tot drie voorbeelden zijn meestal voldoende om een duidelijk patroon vast te leggen.

Chain-of-Thought Prompting

Chain-of-thought prompting vraagt de AI om stap voor stap door een probleem te redeneren voordat het uiteindelijke antwoord wordt gegeven. Deze techniek verbetert de nauwkeurigheid bij complexe taken dramatisch omdat het de AI dwingt om tussenstappen door te werken in plaats van te springen naar een mogelijk onjuiste conclusie. Onderzoek heeft aangetoond dat het toevoegen van "think step by step" aan een prompt de nauwkeurigheid met 30-50% kan verbeteren bij redeneertaken.

Analyze this React component for performance issues. Think step by step:

1. First, identify all state variables and their update patterns
2. Then, check for unnecessary re-renders
3. Next, look for missing memoization opportunities
4. Finally, suggest specific optimizations with code examples

Here's the component:
[component code]

Chain-of-thought prompting is essentieel voor debugging, architectuurbeslissingen en elke taak die logisch redeneren vereist. Door de AI te vragen zijn werk te tonen, krijg je ook de mogelijkheid om zijn redenering te verifiëren en fouten in de tussenstappen op te sporen.

Role-Playing Prompts

Role-playing prompts wijzen een specifieke persona of expertise niveau toe aan de AI, wat de diepgang, stijl en focus van zijn reacties beïnvloedt. Wanneer je de AI zegt te "act as a senior DevOps engineer", verschuift het zijn perspectief om meer operationeel gericht, productie-bestendig advies te geven in plaats van generieke code snippets. Deze techniek maakt gebruik van de training van de AI op domein-specifieke content om meer expert-level output te produceren.

Act as a senior security engineer with 15 years of experience in web application security. Review this authentication implementation and identify any vulnerabilities, ranking them by severity. For each vulnerability, explain the attack vector and provide a secure code fix.

De sleutel tot effectief role-playing is specificiteit. "Act as a Python developer" is te vaag. "Act as a Python developer specializing in high-performance data pipelines using Apache Airflow and pandas" geeft de AI een veel duidelijker referentiekader.

System Prompts versus User Prompts

De meeste AI tools onderscheiden tussen system prompts en user prompts. Een system prompt stelt persistente instructies in die van toepassing zijn op de hele conversatie, terwijl user prompts individuele berichten zijn. Begrip van dit onderscheid is cruciaal voor het behouden van consistentie tijdens een lange interactie.

CLAUDE.md bestand als een persistente system prompt. In ChatGPT kun je aangepaste instructies instellen die fungeren als system prompts voor alle conversaties.

# System prompt example
You are a TypeScript expert working on a Next.js 14 project using:
- App Router (not Pages Router)
- Server Components by default
- Prisma for database access
- Tailwind CSS for styling
- Zod for validation

Always use strict TypeScript. Prefer server actions over API routes.
Never use 'any' type. Use 'unknown' and narrow with type guards.

# User prompt example
Add a user profile page that shows the current user's name, email,
avatar, and last 10 activity records. Include loading states and
error handling.

Essentiële AI Commando's voor Ontwikkelaars

Bepaalde commandopatronen zijn opmerkelijk effectief gebleken bij alle grote AI coding tools. Dit zijn geen letterlijke commando's maar eerder richtinggevende zinnen die consistent hoogwaardige reacties oproepen. Beschouw ze als krachtwoorden die specifieke mogelijkheden in AI modellen activeren.

"Act as..." / "You are a..." — Roltoewijzing

Roltoewijzing is een van de krachtigste commando's in prompt engineering. Door een rol te specificeren, activeer je domein-specifieke kennis en stel je verwachtingen voor de diepgang en stijl van de reactie. Hoe specifieker de rol, hoe beter de output.

You are a senior backend engineer at a fintech company who specializes
in building secure, high-throughput payment processing systems.
You have deep expertise in PostgreSQL, Redis, and distributed systems.
You always consider edge cases, race conditions, and failure modes.

Design a payment processing API that handles:
- Credit card payments via Stripe
- Bank transfers via Plaid
- Retry logic with exponential backoff
- Idempotency keys to prevent duplicate charges

"Step by step" — Chain of Thought

Het toevoegen van "step by step" of "let's think step by step" aan je prompt activeert de AI om zijn redeneerproces op te breken. Dit is bijzonder effectief voor debugging, algoritmeontwerp en architectuurbeslissingen. De stap-voor-stap benadering levert niet alleen betere resultaten op, maar maakt ook de redenering van de AI transparant, waardoor je logische fouten kunt opsporen.

Debug this SQL query that's causing a timeout. Think step by step:

1. First, analyze the query structure and joins
2. Identify potential performance bottlenecks
3. Check for missing indexes
4. Suggest an optimized version with EXPLAIN analysis

SELECT u.name, COUNT(o.id), SUM(o.amount)
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE o.created_at > '2026-01-01'
GROUP BY u.name
HAVING COUNT(o.id) > 10
ORDER BY SUM(o.amount) DESC;

"Think aloud" — Redeneertransparantie

"Think aloud" is vergelijkbaar met "step by step" maar richt zich meer op het besluitvormingsproces van de AI. Het vraagt de AI om zijn redenering te verwoorden, inclusief welke alternatieven het overwoog en waarom het een bepaalde benadering koos. Dit is onschatbaar wanneer je de afwegingen bij een ontwerpbeslissing wilt begrijpen of wanneer je wilt evalueren of de redenering van de AI klopt.

I need to choose between WebSocket and Server-Sent Events for a
real-time notification system. Think aloud about the trade-offs,
considering: browser support, bidirectional communication needs,
server resource usage, and scalability. Then recommend one with
justification.

"Explain like I'm 5" — Vereenvoudiging

Bij het leren van een nieuw concept of het proberen te begrijpen van complexe code verwijdert "explain like I'm 5" (ELI5) jargon en biedt intuïtieve, op analogieën gebaseerde uitleg. Dit is vooral handig voor het instromen op nieuwe projecten, het begrijpen van onbekende codebases of het uitleggen van technische concepten aan niet-technische belanghebbenden.

Explain like I'm 5: What is a monad in functional programming,
and why do Haskell developers keep talking about them?
Use a real-world analogy, not code.

"Review and critique" — Code Review

Het gebruik van "review and critique" geeft de AI het signaal om een kritische houding aan te nemen in plaats van de code simpelweg te accepteren zoals hij is. Dit levert een grondigere analyse op, inclusief mogelijke bugs, beveiligingsproblemen, prestatieproblemen en stijlovertredingen. Het is als het krijgen van een code review van een senior engineer op afroep.

Review and critique this Express.js middleware. Focus on:
- Security vulnerabilities
- Error handling gaps
- Performance concerns
- Best practice violations
- Suggest improvements with code examples

[paste your middleware code]

"Write tests for" — Test Generatie

Test generatie is een van de meest waardevolle toepassingen van AI coding tools. Door "write tests for" te specificeren samen met je testframework en dekkingsverwachtingen, kun je snel uitgebreide test suites genereren. De sleutel is het specificeren van edge cases en testprioriteiten.

Write tests for the UserService.register method using Jest.
Cover these scenarios:
- Happy path with valid input
- Duplicate email registration
- Invalid email format
- Password too short
- Missing required fields
- Database connection failure
- Concurrent registration attempts

Use describe/it blocks. Include setup and teardown.
Mock the database layer.

"Refactor using..." — Patroongebaseerde Refactoring

Het specificeren van een ontwerppatroon of principe in je refactoring prompt geeft de AI een duidelijke doelarchitectuur. In plaats van vage "refactor this" verzoeken, levert het benoemen van het patroon gerichte, consistente refactoring op die gevestigde software engineering principes volgt.

Refactor this notification system using the Strategy pattern.
Currently, all notification types (email, SMS, push) are handled
in a single class with if-else chains. Create separate strategy
classes for each notification type, a context class that delegates
to the active strategy, and a factory for creating strategies.

[paste your current code]

"Find bugs in" — Debugging

Het commando "find bugs in" activeert de analytische modus van de AI, waarbij het wordt gevraagd om naar problemen te zoeken in plaats van alleen code te genereren. Dit werkt het beste wanneer je de code levert, het verwachte gedrag beschrijft en eventuele symptomen noemt die je hebt waargenomen.

Find bugs in this async Node.js function. It's supposed to process
a batch of orders and update their status, but sometimes orders
get processed twice and the status updates are inconsistent under
high load.

[paste your function code]

"Add error handling" — Robuustheid

Veel AI-gegenereerde code snippets werken voor het happy path maar missen de juiste foutafhandeling. Het commando "add error handling" richt zich specifiek op deze kloof, door de AI te vragen om falingsmodi, edge cases en herstelstrategieën te overwegen.

Add error handling to this file upload function. Consider:
- File size limits
- Invalid file types
- Network interruptions during upload
- Disk space errors
- Concurrent upload conflicts
- Partial upload cleanup

Use try-catch with specific error types. Add retry logic for
transient failures. Return meaningful error messages to the client.

Prompt Patronen voor Code Generatie

Naast individuele commando's zijn bepaalde prompt patronen bijzonder effectief gebleken voor specifieke soorten code generatie taken. Deze patronen combineren technieken zoals roltoewijzing, contextlevering en outputspecificatie tot gestructureerde prompts die consistent hoogwaardige resultaten opleveren.

Feature Implementatie Prompts

Bij het implementeren van een nieuwe feature volgen de meest effectieve prompts een specificatie-achtige structuur: beschrijf de feature, specificeer de tech stack, definieer de acceptatiecriteria en noem eventuele beperkingen. Dit geeft de AI een compleet beeld van wat er gebouwd moet worden.

Implement a user avatar upload feature for a Next.js 14 application.

Tech stack: Next.js App Router, TypeScript, Prisma, PostgreSQL, AWS S3

Requirements:
- Accept JPEG, PNG, WebP (max 5MB)
- Resize to 200x200 and 400x400 thumbnails using Sharp
- Upload originals to S3 with unique keys
- Store S3 URLs in the User model
- Delete old avatar when uploading a new one
- Return presigned URLs for frontend display

Acceptance criteria:
- Invalid file types return 400 with error message
- Files over 5MB return 413
- Successful upload returns 200 with avatar URLs
- Old avatars are cleaned up from S3

Create: API route, service layer, Prisma schema update, and types.

API Ontwerp Prompts

API ontwerp prompts profiteren van het vooraf specificeren van de architecturale stijl, authenticatiemethode, versiestrategie en responsformaat. Dit zorgt ervoor dat de gegenereerde API consistent is en de conventies van je project volgt.

Design a RESTful API for a project management application.

Architecture: Express.js with TypeScript, following clean architecture
Auth: JWT with refresh token rotation
Versioning: URL-based (/api/v1/)
Response format: { success: boolean, data?: T, error?: { code, message } }

Endpoints needed:
- Projects CRUD with team membership
- Tasks CRUD with assignee, priority, status
- Comments on tasks with mentions
- Activity feed (recent actions across projects)

Include:
- Request/response TypeScript interfaces
- Zod validation schemas
- Error handling middleware
- Pagination for list endpoints (cursor-based)

Database Schema Prompts

Database schema prompts moeten de ORM, naamgevingsconventies, indexeringsstrategie en relaties specificeren. De AI kan complete schemas genereren met de juiste constraints, indexes en migratiebestanden.

Design a Prisma schema for an e-commerce platform with these entities:

- Users (authentication, profile, addresses)
- Products (variants, categories, inventory)
- Orders (line items, status history, payments)
- Reviews (ratings, images, helpful votes)
- Cart (items, applied coupons)

Requirements:
- Use PostgreSQL with UUID primary keys
- Soft deletes with deletedAt timestamps
- Proper indexes for common query patterns
- Enums for order status, payment status
- Decimal fields for prices (not float)
- Full-text search on product name and description
- Include a migration file

UI Component Prompts

Voor UI componenten levert het specificeren van het framework, de styling benadering, toegankelijkheidseisen en interactieve statussen veel betere resultaten op dan generieke "create a component" prompts.

Create a reusable DataTable component in React with TypeScript.

Styling: Tailwind CSS + shadcn/ui conventions
Features:
- Column definitions with sort, filter, and custom renderers
- Server-side pagination with page size selector
- Row selection (single and multi) with checkboxes
- Loading skeleton state
- Empty state with custom message
- Responsive: card layout on mobile, table on desktop

Accessibility:
- Keyboard navigation (arrow keys, Enter, Escape)
- Screen reader announcements for sort and filter changes
- ARIA labels on all interactive elements

Props interface:
- data, columns, isLoading, pagination, onSort, onFilter, onSelect

Include a usage example with a user list table.

Configuratie en DevOps Prompts

DevOps en configuratie prompts moeten de doelomgeving, beveiligingseisen en eventuele organisatorische standaarden specificeren. Dit voorkomt dat de AI generieke configuraties genereert die niet overeenkomen met je infrastructuur.

Create a Docker Compose setup for a development environment with:
- Next.js app (hot reload enabled)
- PostgreSQL 16 with persistent volume
- Redis for session storage
- MinIO (S3-compatible) for local file storage

Requirements:
- All services on a shared network
- Environment variables from .env file
- Health checks for all services
- Volumes for node_modules (avoid bind mount issues)
- PostgreSQL initialized with seed data
- Non-root containers where possible

Also create:
- Dockerfile for the Next.js app (multi-stage build)
- .env.example with all required variables
- Makefile with common commands (up, down, logs, reset-db)

Geavanceerde Prompting Strategieën

Zodra je de fundamentele technieken en commando's hebt geleerd, helpen deze geavanceerde strategieën je om complexe, meerstapige ontwikkelingstaken aan te pakken die verder gaan dan wat een enkele prompt kan bereiken.

Prompt Chaining

Prompt chaining breekt een complexe taak op in een reeks kleinere, gerichte prompts waarbij elke prompt voortbouwt op de output van de vorige. Deze strategie levert betere resultaten op dan proberen alles in één enkele enorme prompt te doen, omdat elke stap de volledige aandacht en context van de AI krijgt.

# Step 1: Design the architecture
"Design the architecture for a real-time chat application.
List the components, their responsibilities, and how they
communicate. Use a diagram-like text format."

# Step 2: Define the data model
"Based on the architecture above, design the database schema
for the chat application. Include users, conversations,
messages, and read receipts. Use Prisma schema format."

# Step 3: Implement the API
"Implement the REST API for the chat application based on
the architecture and schema we designed. Start with the
message endpoints: send, list, delete."

# Step 4: Add WebSocket support
"Now add WebSocket support for real-time message delivery.
Use Socket.io. Integrate with the existing message API."

# Step 5: Write tests
"Write integration tests for the chat API and WebSocket
events using Jest and Supertest."

De sleutel tot effectieve prompt chaining is ervoor zorgen dat elke stap een complete, bruikbare output produceert voordat je naar de volgende stap gaat. Bekijk elke output, breng waar nodig correcties aan en voer het verfijnde resultaat dan in de volgende prompt in.

Context Stuffing

Context stuffing houdt in dat je de AI alle relevante code, documentatie en context geeft voordat je je vraag stelt. Hoewel dit voor de hand ligt, slaan veel ontwikkelaars deze stap over en vragen zich dan af waarom de AI onjuiste aannames maakt. Hoe meer relevante context je levert, hoe nauwkeuriger en specifieker de reactie van de AI zal zijn.

 {
    await this.db.query('UPDATE users SET email = $1 WHERE id = $2', [email, id]);
    await this.cache.del(`user:${id}`);
  }
}
```

Here is the User type:
```typescript
interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
  createdAt: Date;
}
```

Now, add an updateProfile method that allows updating name and email,
with validation that the email is not already taken by another user.

Merk op hoe het leveren van de bestaande code en types de AI in staat stelt om een methode te genereren die perfect consistent is met de bestaande patronen, dezelfde caching strategie gebruikt en de bestaande typedefinities respecteert.

Constraint Specificatie

Het instellen van expliciete constraints voorkomt dat de AI ongewenste aannames maakt. Constraints definiëren wat de AI NIET moet doen, wat vaak even belangrijk is als wat het wel moet doen. Veelvoorkomende constraints zijn technologieversies, prestatie-eisen, beveiligingsregels en codeerstandaarden.

Build a URL shortener API with these constraints:

MUST:
- Use Node.js 20+ with native fetch (no axios)
- Use PostgreSQL via pg driver (no ORM)
- Generate short codes of exactly 7 characters
- Support custom aliases (max 20 chars)
- Return 301 for existing short URLs
- Rate limit to 100 creates per hour per IP

MUST NOT:
- Use any ORM or query builder
- Store full URLs without normalization
- Allow short codes that conflict with existing routes
- Return database errors to the client

PERFORMANCE:
- Handle 10,000 requests per second
- Cache hot URLs in Redis with 5-minute TTL
- P99 latency under 50ms for redirects

Output Formaat Controle

Het specificeren van het gewenste outputformaat zorgt ervoor dat de reactie van de AI direct bruikbaar is zonder herformattering. Dit is vooral belangrijk wanneer de output door andere tools moet worden geparseerd, in documentatie moet worden ingevoegd of als configuratiebestanden moet worden gebruikt.

Analyze this codebase and provide the output in this exact format:

## Architecture Overview
[2-3 paragraph summary]

## Component Diagram
```mermaid
graph TD
    [components and relationships]
```

## API Endpoints
| Method | Path | Description | Auth |
|--------|------|-------------|------|

## Database Tables
| Table | Columns | Indexes | Relations |
|-------|---------|---------|-----------|

## Recommendations
1. [Priority] [Description] - [Estimated effort]
2. ...

## Technical Debt
- [ ] [Description] - [Impact: High/Medium/Low]

Iteratieve Verfijning

Iteratieve verfijning is de praktijk van het progressief verbeteren van AI-output door middel van vervolgprompts. De eerste reactie is zelden perfect, maar het biedt een startpunt dat je kunt verfijnen. Elke iteratie komt efficiënter bij het gewenste resultaat dan proberen alles in één enkele prompt goed te krijgen.

# Iteration 1: Get a starting point
"Write a rate limiter middleware for Express.js"

# Iteration 2: Add specificity
"Good start. Now modify it to use Redis for distributed
rate limiting across multiple server instances. Use sliding
window instead of fixed window."

# Iteration 3: Add edge cases
"Add handling for: Redis connection failures (fall back to
in-memory), custom rate limits per route, burst allowance
for legitimate traffic spikes, and proper headers
(X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset)."

# Iteration 4: Add tests
"Write comprehensive tests for all the scenarios we've
covered, including Redis failures and burst handling."

Deze iteratieve benadering is effectiever dan het schrijven van één enkele enorme prompt omdat elke iteratie je in staat stelt om bij te sturen en details toe te voegen op basis van de vorige output van de AI. Het weerspiegelt hoe je met een menselijke ontwikkelaar zou werken: begin met een ruwe implementatie en verfijn deze dan.

Tool-Specifieke Prompting Tips

Hoewel de bovenstaande technieken werken bij alle AI tools, heeft elk platform unieke sterke punten en eigenaardigheden. Het aanpassen van je prompting stijl aan de kenmerken van elke tool kan je resultaten aanzienlijk verbeteren.

ChatGPT / GPT-4

ChatGPT en GPT-4 blinken uit in conversationele interacties en profiteren van gestructureerde, goed georganiseerde prompts. Ze gaan goed om met lange context en zijn bijzonder goed in het uitleggen van concepten en het genereren van documentatie.

• Gebruik aangepaste instructies: Stel je tech stack en voorkeuren in in de aangepaste instructies van ChatGPT, zodat je ze niet in elke conversatie hoeft te herhalen.
• Gebruik Code Interpreter: Voor data-analysetaken, vraag ChatGPT om Code Interpreter te gebruiken om Python code uit te voeren en visualisaties te genereren.
• Gebruik markdown opmaak in prompts: GPT-4 reageert goed op gestructureerde prompts met headers, bullet points en code blocks.
• Specificeer de responslengte: GPT-4 neigt naar breedsprakigheid. Voeg "be concise" of "in under 200 words" toe wanneer je beknoptheid nodig hebt.
• Gebruik het system message: In de API, gebruik het system message voor persistente instructies zoals codeerstandaarden en projectcontext.

# Effective GPT-4 prompt structure
**Role:** Senior TypeScript developer
**Task:** Implement a JWT authentication middleware
**Context:** Express.js API, PostgreSQL, existing User model
**Constraints:** No external auth libraries, use crypto module
**Output:** Complete, production-ready code with types
**Format:** Single file with inline comments for complex logic

Claude / Claude Code

Claude en Claude Code zijn bijzonder sterk in het begrijpen van grote codebases, het opvolgen van complexe instructies en het produceren van goed gestructureerde output. De agentic mogelijkheden van Claude Code maken het ideaal voor meerstapige taken.

• Gebruik CLAUDE.md: Dit is het meest impactvolle wat je kunt doen. Plaats je projectcontext, conventies en voorkeuren in CLAUDE.md.
• Wees expliciet over bestandslocaties: Claude Code werkt het beste wanneer je specificeert welke bestanden moeten worden gelezen en gewijzigd.
• Laat het commando's uitvoeren: Claude Code kan tests en build commando's uitvoeren. Vraag het om zijn werk te verifiëren door tests uit te voeren.
• Gebruik /compact voor lange sessies: Wanneer de context lang wordt, gebruik /compact om de conversatie te comprimeren met behoud van de belangrijkste informatie.
• Gebruik XML tags: Claude reageert goed op secties met XML-tags in prompts voor duidelijke afbakening van verschillende delen van je verzoek.

# Effective Claude Code prompt
Read the following files to understand the current architecture:
- src/routes/userRoutes.ts
- src/middleware/authMiddleware.ts
- src/models/User.ts

Then refactor the authentication flow to support:
1. JWT access tokens (15 min expiry) + refresh tokens (7 day expiry)
2. Token rotation on refresh (invalidate old refresh token)
3. Rate limiting on the refresh endpoint (5 per minute per user)

Update all related files and run the test suite when done.

GitHub Copilot

GitHub Copilot werkt anders dan op chat gebaseerde tools — het biedt inline suggesties terwijl je typt. Effectief Copilot gebruik berust op het schrijven van code die je intentie duidelijk aangeeft via comments, type signatures en omringende context.

• Schrijf beschrijvende comments: Een comment zoals // Validate email format and check for duplicates voor een functie geeft Copilot duidelijke intentie.
• Gebruik TypeScript types: Goed gedefinieerde types en interfaces leiden Copilot naar juiste implementaties.
• Geef voorbeelden in comments: Het tonen van verwachte input/output in comments helpt Copilot om je gewenste formaat te matchen.
• Accepteer gedeeltelijke suggesties: Soms krijgt Copilot de structuur goed maar de details fout. Accepteer de suggestie en bewerk de details.
• Gebruik Copilot Chat voor complexe taken: Voor multi-file wijzigingen of architectuurbeslissingen, gebruik Copilot Chat in plaats van inline suggesties.

> {
  // Copilot will generate the implementation based on these types

Cursor

Cursor combineert IDE-integratie met AI chat mogelijkheden en biedt zowel inline completions als een chat interface die je codebase begrijpt. De kracht ligt in diep projectbewustzijn en de mogelijkheid om naar specifieke bestanden en symbols te verwijzen.

• Gebruik @file referenties: Verwijs naar specifieke bestanden met @filename om Cursor precieze context te geven.
• Gebruik @codebase voor brede context: Wanneer je wilt dat Cursor het hele project doorzoekt, gebruik @codebase.
• Gebruik @docs voor bibliotheekdocumentatie: Cursor kan verwijzen naar documentatie van derden bibliotheken met @docs.
• Gebruik Cmd+K voor inline bewerkingen: Selecteer code en gebruik Cmd+K om wijzigingen in natuurlijke taal te beschrijven.
• Stel projectregels in: Gebruik het .cursorrules bestand (vergelijkbaar met CLAUDE.md) voor persistente projectinstructies.

# Effective Cursor prompt
@src/services/paymentService.ts @src/types/payment.ts

Refactor the processPayment function to use the Strategy pattern.
Create separate strategy classes for each payment provider
(Stripe, PayPal, BankTransfer). The function should accept a
payment method and delegate to the appropriate strategy.

Keep the same public API so existing callers don't break.

Codex CLI

Codex CLI is OpenAI's terminal-gebaseerde coding agent, vergelijkbaar in concept met Claude Code. Het blinkt uit in het uitvoeren van meerstapige ontwikkelingstaken vanaf de commandoregel.

• Geef een duidelijk doel: Codex CLI werkt het beste met een duidelijk, hoog niveau doel in plaats van stap-voor-stap instructies.
• Specificeer de werkmap: Zorg ervoor dat je Codex CLI uitvoert vanuit de juiste project root.
• Gebruik eerst proposal mode: Voordat je Codex wijzigingen laat aanbrengen, gebruik proposal mode om zijn plan te bekijken.
• Stel sandbox permissies zorgvuldig in: Beheer wat Codex kan uitvoeren door sandbox permissies te configureren.
• Itereer op de output: Zoals bij andere tools, kan de eerste poging verfijning nodig hebben via vervolgprompts.

Veelvoorkomende Fouten om te Vermijden

Zelfs ervaren ontwikkelaars maken deze veelvoorkomende prompting fouten. Ze herkennen en vermijden zal je AI-interacties onmiddellijk verbeteren.

Vage Instructies

De meest voorkomende fout is het geven van vage, onvoldoende gespecificeerde instructies. Prompts zoals "fix this", "make it better" of "add a feature" geven de AI vrijwel niets om mee te werken. De AI zal aannames maken, en die aannames komen vaak niet overeen met je intentie.

# Bad
"Fix the login bug"

# Good
"Fix the bug where users with uppercase emails cannot log in.
The issue is in src/auth/login.ts - the email comparison is
case-sensitive but emails are stored in lowercase in the database.
The fix should normalize the email to lowercase before comparison."

Ontbrekende Context

AI modellen kennen je project niet tenzij je het ze vertelt. Het niet leveren van relevante context — je tech stack, framework versie, bestaande code patronen of projectstructuur — dwingt de AI om te gissen, vaak onjuist. Neem altijd de context op die een nieuw teamlid nodig zou hebben om je verzoek te begrijpen.

# Bad
"Write a function to send emails"

# Good
"Write an email sending function for our NestJS application.
We use:
- @nestjs/mailer with Handlebars templates
- SMTP via AWS SES
- Templates stored in src/templates/emails/
- Existing MailService class in src/mail/mail.service.ts

The function should accept a template name, recipient, and
template variables. Include error handling for SES throttling
and bounce notifications."

Overbelaste Prompts

Proberen te veel ongerelateerde taken in één enkele prompt te doen leidt tot middelmatige resultaten over de hele linie. De aandacht van de AI is verdeeld, en het kan belangrijke details voor sommige taken overslaan terwijl het zich te veel op andere richt. Breek complexe verzoeken op in gerichte, opeenvolgende prompts.

# Bad - Too many tasks in one prompt
"Build a complete user management system with authentication,
profile management, email verification, password reset,
role-based access control, and an admin dashboard"

# Good - Break it into focused prompts
Prompt 1: "Design the database schema for a user management system..."
Prompt 2: "Implement the authentication endpoints..."
Prompt 3: "Add email verification flow..."
Prompt 4: "Implement role-based access control middleware..."

Output Formaat Negeren

Wanneer je output in een specifiek formaat nodig hebt — JSON, markdown, een bepaalde bestandsstructuur — leidt het niet specificeren hiervan tot onvoorspelbare opmaak. De AI kan proza retourneren wanneer je JSON nodig hebt, of een enkel bestand wanneer je meerdere bestanden nodig hebt. Specificeer het gewenste outputformaat altijd expliciet.

# Bad
"List all the API endpoints"

# Good
"List all API endpoints in a markdown table with these columns:
| Method | Path | Description | Auth Required | Request Body | Response |"

Niet Itereren

Het accepteren van de eerste reactie van de AI zonder verfijning is een gemiste kans. De eerste reactie biedt een fundament dat je kunt verbeteren door vervolgprompts. Iteratie is waar de echte kracht van AI-ondersteunde ontwikkeling naar voren komt — elke cyclus levert betere, meer verfijnde output op.

# Instead of accepting the first response, iterate:
"Good start. Now add input validation using Zod schemas."
"Now add proper error handling with custom error classes."
"Now add logging for all operations."
"Now write tests for all the edge cases we've discussed."

Prompt Templates Bibliotheek

Hier zijn kant-en-klare prompt templates voor veelvoorkomende ontwikkelaarstaken. Kopieer deze templates, vul de placeholders in en pas ze aan aan je specifieke behoeften. Elke template combineert meerdere prompting technieken voor maximale effectiviteit.

Template 1: Feature Implementatie

You are a senior {language} developer specializing in {framework}.

Implement {feature_description} for our {project_type} application.

Tech stack:
- {language} {version} with {framework} {version}
- {database} for data storage
- {orm} for database access
- {testing_framework} for tests

Requirements:
- {requirement_1}
- {requirement_2}
- {requirement_3}

Constraints:
- Must follow existing patterns in the codebase
- Must include input validation
- Must handle errors gracefully
- Must be backward compatible

Output:
1. Implementation code with inline comments for complex logic
2. Unit tests covering happy path and edge cases
3. Brief explanation of design decisions

Template 2: Bug Onderzoek

You are a debugging specialist with expertise in {language}/{framework}.

Investigate and fix this bug:

**Symptom:** {describe_the_observed_behavior}
**Expected:** {describe_the_expected_behavior}
**Frequency:** {always/sometimes/under_specific_conditions}
**Environment:** {production/staging/development}

Relevant code:
```
{paste_relevant_code}
```

Error output / stack trace:
```
{paste_error_output}
```

Think step by step:
1. Identify the root cause
2. Explain why this bug occurs
3. Provide the fix with code
4. Suggest how to prevent similar bugs
5. Write a regression test

Template 3: Code Review

You are a senior code reviewer at a {company_type} company.

Review this {language} code for:

1. **Correctness:** Logic errors, off-by-one errors, null handling
2. **Security:** Injection, XSS, auth bypasses, data exposure
3. **Performance:** N+1 queries, unnecessary allocations, missing caches
4. **Maintainability:** Code smells, naming, complexity
5. **Testing:** Missing test cases, brittle tests

Code to review:
```
{paste_code}
```

For each issue found, provide:
- Severity: 🔴 Critical / 🟡 Warning / 🔵 Info
- Category: Which of the 5 areas above
- Description: What's wrong and why
- Suggestion: How to fix it, with code example

End with an overall assessment and top 3 priorities.

Template 4: API Endpoint Ontwerp

Design a {http_method} {endpoint_path} endpoint for {resource_description}.

Framework: {framework}
Auth: {auth_method}
Database: {database}

The endpoint should:
- {functionality_1}
- {functionality_2}
- {functionality_3}

Provide:
1. Route definition with middleware chain
2. Request validation schema ({validation_library})
3. Controller/handler function
4. Service layer function
5. Database query/function
6. Response types (success and error)
7. Example curl request and response

Template 5: Database Migratie

Create a database migration for {change_description}.

Current schema:
```
{current_schema}
```

Desired changes:
- {change_1}
- {change_2}

ORM: {orm_name}
Database: {database_type}

Requirements:
- Migration must be reversible (include down migration)
- Preserve existing data (write data migration SQL if needed)
- Add appropriate indexes for new columns
- Consider performance impact on large tables
- Include rollback safety checks

Template 6: Test Suite Generatie

Write a comprehensive test suite for {function_or_class_name}.

Testing framework: {framework}
Mocking library: {library}

Code under test:
```
{paste_code}
```

Test categories to cover:
- ✅ Happy path: All valid inputs produce correct outputs
- 🔄 Edge cases: Empty inputs, boundary values, null/undefined
- ❌ Error cases: Invalid inputs, permission denied, network failures
- 🏎️ Performance: Response time expectations for critical paths
- 🔒 Security: Auth checks, input sanitization

For each test:
- Use descriptive test names that read like documentation
- Follow Arrange-Act-Assert pattern
- Include setup/teardown for shared state
- Mock external dependencies

Template 7: Refactoring Plan

You are a software architect specializing in {language} refactoring.

Current code:
```
{paste_current_code}
```

Problems with current code:
- {problem_1}
- {problem_2}

Refactor using {pattern_or_principle}.

Provide:
1. **Analysis:** What's wrong and why the current approach doesn't scale
2. **Target Architecture:** How the refactored code should be structured
3. **Step-by-step Plan:** Ordered refactoring steps (safe, incremental)
4. **Refactored Code:** Complete implementation
5. **Migration Guide:** How to transition from old to new without breaking changes
6. **Risk Assessment:** What could go wrong and how to mitigate

Template 8: Documentatie Generatie

Generate documentation for this {language} code:

```
{paste_code}
```

Documentation type: {JSDoc/TSDoc/Python docstrings/README section}

Requirements:
- Document all public functions/classes/methods
- Include parameter descriptions with types
- Include return type descriptions
- Add usage examples for non-obvious APIs
- Note any side effects or important caveats
- Use {style_guide} conventions

For README documentation, include:
- Overview (1-2 paragraphs)
- Installation instructions
- Quick start example
- API reference table
- Configuration options

Template 9: Prestatie Optimalisatie

You are a performance engineering specialist.

Analyze and optimize this code for performance:

```
{paste_code}
```

Current performance:
- {metric}: {current_value}
- Target: {target_value}
- Bottleneck suspected at: {location}

Optimization constraints:
- Must not change the public API
- Must maintain all existing test passes
- Must not sacrifice readability for micro-optimizations
- {additional_constraint}

Provide:
1. **Profiling Analysis:** Where time/memory is being spent
2. **Optimization Strategies:** Ranked by expected impact
3. **Optimized Code:** With comments explaining each change
4. **Benchmark Comparison:** Before vs after expected metrics
5. **Trade-offs:** Any readability or complexity costs

Template 10: Security Audit

You are a security engineer specializing in {language}/{framework} security.

Perform a security audit on this code:

```
{paste_code}
```

Check for:
- Injection attacks (SQL, NoSQL, command, LDAP)
- Authentication and authorization bypasses
- Cross-site scripting (XSS) vulnerabilities
- Cross-site request forgery (CSRF) exposure
- Insecure direct object references (IDOR)
- Sensitive data exposure (logging, error messages)
- Insecure cryptography or key management
- Race conditions in concurrent operations
- Denial of service vulnerabilities

For each finding:
- Severity: Critical / High / Medium / Low
- OWASP Category: Which Top 10 category
- Description: Clear explanation of the vulnerability
- Attack Scenario: How an attacker would exploit it
- Remediation: Specific code fix
- Verification: How to confirm the fix works