Agentic Coding part 1: Cursor’s best practices

De afgelopen maanden heeft onze collega Niels intensief gewerkt met AI ondersteunde development tools. Wat begon als “even uitproberen” is uitgegroeid tot een fundamenteel andere manier van werken. Niet omdat AI op magische wijze code schrijft, maar omdat het zijn workflow heeft veranderd.

Dit artikel is het startpunt van een serie over agentic coding, een term die je steeds vaker hoort, maar waar weinig concrete handvatten voor worden gegeven. In deze reeks deelt Niels zijn ervaringen: wat werkt wel, wat juist niet, en hoe je met AI productiever kunt werken zonder concessies te doen aan kwaliteit.

In dit eerste artikel trapt Niels af met een praktische introductie tot Cursor en de features die voor hem het verschil maken.

1) Wat is “agentic coding”?

Bij traditioneel AI-assisted development vraag je om een stuk code en accepteer (of verwerp)je het resultaat. Bij agentic coding gaat het verder: de AI leest zelf je codebase, stelt vragen, maakt een plan, voert changes uit over meerdere files, en helpt je verifiëren dat het werkt.

De cyclus ziet er zo uit: context verzamelen → plan maken → changes doorvoeren → verifiëren → itereren.

Jouw rol verandert: je geeft richting, stelt randvoorwaarden, en bewaakt kwaliteit. De AI doet grotendeels het uitvoerende werk.

2) Wat is Cursor?

Cursor is een AI-native code editor gebouwd op VS Code. Het combineert alles wat je kent van VS Code (extensions, keybindings, settings) met geïntegreerde AI-features, zoals:

• Agent chat: vraag de AI om code te schrijven, uitleg te geven, of problemen op te lossen
• Inline edits: selecteer code en geef een instructie, de AI past het direct aan
• Tab completion: intelligente autocomplete die leert van je edits
• Agent modes: Plan, Agent, Ask, Debug, verschillende workflows voor verschillende taken
• Context: verwijs naar files, folders, de hele codebase, of zelfs een browser
• Browser Automation: Agents sturen autonoom een in-editor browser aan voor debugging en verificatie taken

Waarom Cursor?

Cursor gaat verder dan autocomplete. Het is gebouwd voor agentic workflows: de AI kan zelf code lezen, plannen maken, meerdere bestandenaanpassen, opdrachten uitvoeren, en errors oplossen. Jij blijft in control, maar het zware werk wordt gedaan.

Referentie: cursor.com

3) Edit-stijlen: hoe je met Cursor interacteert

Cursor biedt verschillende manieren om met de AI te werken. Dit zijn geen “modes”, maar interactiemethodes: hoe je code selecteert, context toevoegt, en edits triggert.

Referentie: cursor.com/docs/inline-edit/overview

3.1 Inline edit

Hoe: selecteer code, druk Cmd+K (of Ctrl+K), en geef een korte instructie. Cursor past de selectie direct aan.

Gebruik voor: rename, kleine refactors, error fixes, betere benaming, comments toevoegen, kleine UI tweaks.

Tip: houd de instructie gefocust, één intent per edit.

Voorbeeld:

3.2 Code selecteren + Chat

Hoe: selecteer code in je editor en open Chat (Cmd+L). De selectie wordt automatisch als context meegegeven.

Gebruik voor: uitleg vragen over specifieke code, refactor-suggesties krijgen, of de selectie als startpunt voor een grotere taak.

Tip: combineer met @file of @folder om extra context toe te voegen.

Voorbeeld:

3.3 Chat (zonder selectie)

Hoe: open Chat en beschrijf wat je wilt. Voeg context toe met @file of @folder.

Gebruik voor: nieuwe features, multi-file changes, vragen over de codebase, scaffolding, trade-off discussies.

Voorbeeld (bestaande code aanpassen):

@folder src/lib/components
Voeg een loading skeleton toe aan alle card components. Zorg dat het consistent is met de bestaande styling.

Voorbeeld (nieuwe code scaffolden):

Maak een nieuwe API route voor user preferences met GET en PUT endpoints, Zod validation en TypeScript types.

3.4 Tab completion

Tab is Cursor’s gespecialiseerde auto complete model. Het leert van je edits: hoe meer je accepteert (Tab) of afwijst (Escape), hoe beter de suggesties worden.

Referentie: cursor.com/docs/tab/overview

Wat kan Tab:

• Multi-line edits: niet alleen de huidige regel, maar meerdere regels tegelijk aanpassen
• Auto-imports: automatisch import statements toevoegen (TypeScript, Python)
• Jump in file: na een edit springt Tab naar de volgende logische plek om te editen
• Jump across files: suggesties voor gerelateerde edits in andere files
• Context-aware: gebaseerd op recente changes, linter errors, en geaccepteerde edits

Keyboard shortcuts:

• Tab: accepteer suggestie
• Escape: verwerp suggestie
• Cmd+→: accepteer woord-voor-woord (partial accept)

Tips:

• Laat Tab “leren” door consequent te accepteren/verwerpen
• Gebruik Tab in Peek views om signatures aan te passen en call sites te fixen

4) Cursor agent modes: Ask / Plan / Agent / Debug

Naast “hoe” je edit (inline/chat/multi-file) is er ook “in welke modus” je Cursor agents inzet.

Referentie: Cursor documentatie over modes (incl. Plan) staat hier: cursor.com/docs/agent/modes.

4.1 Ask (begrijpen & beslissen)

Gebruik voor: codebase begrijpen, patterns uitleggen, trade-offs, “welke optie is beter?”.
Output: read-only exploratie en uitleg, geen automatische code changes.

Voorbeeldprompt:

4.2 Plan (scope, aanpak & guardrails)

Gebruik voor: complexere wijzigingenwaarbij je eerst een reviewbaar plan wil.
Output: (1) verduidelijkende vragen, (2) codebase research, (3) een gedetailleerd plan dat je kunt reviewen en aanpassen voordat er code geschreven wordt.

Hoe Plan mode werkt (praktisch):

• Stap 1, verduidelijk: de agent stelt gerichte vragen om requirements scherp te krijgen.
• Stap 2, onderzoek: de agent verkent relevante code (read/search) om context te verzamelen.
• Stap 3, Plan: je krijgt een concreet implementatieplan (TODO’s + files-to-touch + risico’s + checks).
• Stap 4, Review/Edit: jij past het plan aan (in een markdown plan file).
• Stap 5, bouw: pas als jij op Build klikt gaat Cursor het plan uitvoeren.

Plannen worden door Cursor als (tijdelijke) plan file getoond; als je ze wilt bewaren kun je ze opslaan in .cursor/plans/.

Voorbeeldprompt:

Build phase (na jouw akkoord):

• Je hoeft niets extra’s te prompten: na je review klik je op “Build” en Cursor voert het plan uit (multi-file changes, commands runnen, errors fixen).
• Ik blijf “in the loop” met checkpoints: na grote stappen kort verifiëren (build/tests) en pas dan door.

4.3 Agent (uitvoeren & implementeren)

Gebruik voor: directe implementatie van features, refactors, end-to-end slices, wanneer je geen uitgebreid plan vooraf nodig hebt.
Output: concrete code changes (multi-file), commands runnen, errors fixen.

Net als bij Plan mode beschrijf je gewoon wat je wilt + context/randvoorwaarden; de agent gaat zelf aan de slag.

Voorbeeldprompt:

@folder src/lib/components @file src/routes/settings/+page.svelte

Voeg een dark mode toggle toe aan de settings pagina. Gebruik de bestaande CSS variables, sla de voorkeur op in localStorage.

4.4 Debug (root cause, kleinste veilige fix)

Gebruik voor: failing tests, runtime errors, rare edge cases, regressies.
Output: root cause analyse + minimale fix + regressietest.

Voorbeeldprompt:

5) Context geven: @file, @folder, @Codebase, @Browser

AI-output verbetert meestal door betere context, prompts en betere constraints.

Referentie: cursor.com/docs/context/mentions

5.1 Context-strategie

• Context klein houden: voeg alleen toe wat nodig is (relevante files/folders).
• Context expliciet maken: noem bestanden en scope (“pas alleen X aan”).
• Context levend houden: laat de agent eerst samenvatten wat hij ziet en welke aannames hij maakt.

Tip: Begin voor elke change een nieuwe chat, dit houdt de context klein en voorkomt vervuiling.

5.2 Prompt-template: context + guardrails

@folder src/lib/components @file src/routes/dashboard/+page.svelte

Maak een sales metrics card voor het dashboard die total revenue toont. Moet loading en error states hebben, geen nieuwe dependencies.

5.3 “Done” concreet maken

Voorbeelden die goed werken:

• “Empty state + error state + loading state zijn aanwezig”
• “Geen nieuwe dependencies”
• “TypeScript strict blijft groen”
• “Unit tests coveren edge cases”

5.4 @Browser: visuele verificatie

Cursor heeft een ingebouwde browser die je via @Browser als context kunt meegeven. Hiermee kan de agent:

• Screenshots maken en visueel checken wat er op de pagina staat
• De DOM uitlezen en specifieke elementen vinden
• Klikken, typen, navigeren, net als een echte gebruiker

Hoe het werkt:

1. Open de in-editor browser (via Command Palette of de browser icoon in de chat)
2. Navigeer naar de pagina die je wilt testen
3. In je prompt: gebruik @Browser om de huidige pagina als context mee te geven

Voorbeeldprompt:

@Browser Check of de dashboard metrics goed werken. Zie je de Total Revenue card en sales chart? Staan er errors in de console?

Tips:

• Wees specifiek over wat je verwacht te zien
• Gebruik het voor verificatie, niet als vervanging voor echte tests
• Combineer met Debug mode voor runtime issues

6) Rules: persistente instructies voor de agent

LLMs hebben geen geheugen tussen sessies. Rules lossen dit op: ze geven de agent consistente, herbruikbare context die automatisch wordt meegenomen, zonder dat je elke keer dezelfde instructies hoeft te herhalen.

Referentie: cursor.com/docs/context/rules

6.1 4 soorten Rules

Type	Waar	Scope	Wanneer gebruiken
Project Rules	.cursor/rules/	Per project (version controlled)	Codebase-specifieke conventies, templates, workflows
User Rules	Cursor Settings -> Rules	Globaal (al je projecten)	Persoonlijke voorkeuren (communicatiestijl, formatting)
Team Rules	Cursor Dashboard	Heel je team/org	Organisatie-brede standaarden (security, compliance)
AGENTS.md	Project root (of subdirs)	Per project/folder	Simpele instructies zonder metadata overhead

6.2 Project Rules (waar je het meest mee werkt)

Project Rules leven in .cursor/rules/ en bestaan uit folders met een RULE.md file. Je kunt per rule instellen hoe deze wordt toegepast:

• Always Apply: elke chat sessie
• Apply Intelligently: agent beslist op basis van description
• Apply to Specific Files: alleen bij bepaalde file patterns (globs)
• Apply Manually: alleen als je de rule @mentioned (@my-rule)

Voorbeeld folder structuur:

.cursor/rules/
  api-conventions/
    RULE.md           # Hoofdregel
    templates/        # Optionele templates
  component-style/
    RULE.md

Voorbeeld RULE.md:

---
description: "Conventies voor Go API services"
alwaysApply: false
---

Bij het maken van API endpoints:
- Gebruik de standaard error response struct
- Altijd input validation met proper error messages
- Log naar structured logger, geen fmt.Println
- Voeg OpenAPI comments toe voor documentatie

@templates/api-handler.go

6.3 AGENTS.md (de simpele variant)

Voor projecten waar je geen complexe rule configuratie nodig hebt, kun je een AGENTS.md file in je project root zetten. Dit is gewoon markdown, geen metadata, geen folders.

# Project Instructions

## Code Style
- TypeScript voor alle nieuwe files
- Functionele React components (geen classes)
- snake_case voor database kolommen

## Architecture
- Repository pattern voor data access
- Business logic in service layer, niet in handlers

Nested AGENTS.md: je kunt ook AGENTS.md files in subdirectories plaatsen. Instructies worden gecombineerd, met diepere directories die voorrang krijgen.

6.4 Praktische tips voor Rules

• Houd rules kort (< 500 regels), splits grote rules op in meerdere composable rules
• Geef concrete voorbeelden of refereer naar template files met @filename
• Vermijd vage guidance, schrijf rules alsof het interne documentatie is
• Hergebruik rules wanneer je merkt dat je dezelfde prompts herhaalt in chat
• Version control je rules, ze zijn onderdeel van je codebase

7) Modelkeuze: welk model wanneer?

Cursor ondersteunt meerdere AI-modellen. De keuze heeft impact op kwaliteit, snelheid en kosten.

Dit is hoe ik het aanpak:

Referentie: docs.cursor.com/settings/models

7.1 Modellen die ik gebruik

Model	Sterke punten	Zwakke punten	Wanneer gebruiken
Claude Sonnet 4.5	Uitstekend in code, lange context (200k), snel, goede planning	Soms te uitgebreid in uitleg	Default voor dagelijkse development
Claude Opus 4.5	Beste reasoning, diepste analyse, complexe architectuur	Langzamer, duurder	Architectuur, security reviews, lastige bugs
GPT-5.3 Codex	Geoptimaliseerd voor code, zeer snel, goede autocomplete	Minder sterk in lange context	Inline edits, autocomplete, snelle fixes
GPT-5.2	Sterk in redeneren, goed in uitleg, breed getraind	Minder code-gespecialiseerd dan Codex	Documentatie, uitleg, trade-off discussies

7.2 Thinking vs non-thinking modes

Sommige modellen (zoals Claude Opus) hebben een “thinking” mode waarbij het model eerst redeneert voordat het antwoordt. Dit kost meer tokens (hogere kosten) maar levert betere output bij complexe taken.

Wanneer thinking mode gebruiken:

• Complexe refactors die meerdere files raken
• Architectuurbeslissingen
• Security/performance reviews
• Debugging van lastige issues

Wanneer non-thinking (sneller, goedkoper):

• Eenvoudige code generatie
• Documentatie schrijven
• Kleine fixes en renames
• Autocomplete-achtige taken

7.3 Kostenbewust werken

Tips om kosten te beheersen zonder kwaliteit te verliezen:

• Gebruik het juiste model voor de taak: niet elk probleem vereist Opus met thinking
• Beperk context: minder tokens in,minder kosten. Voeg alleen relevante files toe
• Gebruik Plan mode voor grote taken: één goed plan + build is goedkoper dan 10 losse agent runs
• Schakel naar snellere modellen voor iteratie: gebruik Sonnet 4.5voor snelle feedback loops

Referentie: cursor.com/docs/models#model-pricing

Afsluiting

Na maanden dagelijks met Cursor te werken, is mijn conclusie simpel: agentic coding is geen trucje, het is een andere manier van werken. De winst zit niet in “AI schrijft mijn code”, maar in de combinatie van snelle iteraties, slimme context, en het feit dat je in control blijft.

De features die ik in dit artikel heb beschreven (modes, context, rules, modelkeuze) zijn de basis. Maar er is meer. In de volgende blogpost duik ik in MCP (Model Context Protocol): hoe je Cursor kunt integreren met externe tools, databases, en API’s om de agent nog krachtiger te maken.

Tot die tijd: probeer het uit! Begin klein, met één feature of één refactor en blijf experimenteren!