Cursor-functies: Tab, de Agent, rules, context en MCP

Oppervlakken

Cursor is meer dan een editorvenster

Voordat we per functie de diepte in gaan: Cursor draait op meerdere plekken, en niet elke functie zit overal. Dat is de eerste verwarring die je wegneemt. De vertrouwde editor is er een van, maar Cursor heeft er sinds versie 3 een tweede hoofdvenster naast gezet dat om de agents heen is gebouwd, plus een terminalversie, een webversie en apps voor telefoon en iPad.

Editor of Agents Window: het is geen of-of

De documentatie omschrijft het Agents Window als "a unified workspace to build with agents across repos and environments, including local, cloud, remote SSH, and more". Je opent het met het commandopalet (Cmd + Shift + P, dan "Open Agents Window") en je gaat terug met "Open IDE". Ze mogen ook allebei tegelijk openstaan. Cursor geeft zelf een heldere vuistregel: neem het Agents Window als je veel parallelle agents beheert of vooral bouwt met agents, en blijf in de klassieke editor als je met VS Code-extensies werkt of een schermindeling met meerdere bestanden naast elkaar wilt.

Waarom dit onderscheid ertoe doet

Een aantal functies bestaat alleen in het Agents Window. Design mode is daar een voorbeeld van, netwerkverkeer uitlezen met de browsertool werkt op dit moment alleen in het Agent-paneel, en het overzicht van cloudtaken zit er ook. Kom je een functie tegen in een Engelstalige tutorial die je in je editor niet kunt vinden, controleer dan eerst of je in het juiste venster zit. Dat scheelt een halve avond zoeken in instellingen.

Tab

Tab: autocomplete die je hele bewerking voorspelt, niet je volgende woord

De officiele naam is simpelweg Tab. Cursor omschrijft het als "Cursor's AI-powered autocomplete. It suggests code as you type, based on your recent edits, surrounding code, and linter errors." Die drie signalen zijn het hele verhaal: Tab kijkt niet alleen naar wat er links van je cursor staat, maar ook naar wat je de afgelopen minuten hebt veranderd en naar de fouten die je linter meldt.

Waarin het verschilt van gewone autocomplete

Klassieke autocomplete vult af waar je cursor staat. Tab doet drie dingen die daar wezenlijk van afwijken. Ten eerste past het meerdere regels tegelijk aan en voegt het ontbrekende imports toe, dus het bewerkt bestaande code in plaats van alleen nieuwe code aan te plakken. Ten tweede is er jump-in-file: druk je na een geaccepteerde suggestie nog een keer op Tab, dan voorspelt Cursor waar je volgende bewerking komt en springt het daarheen, zodat je niet zelf zit te scrollen. Ten derde voorspelt Tab bewerkingen in andere bestanden wanneer een wijziging daar consequenties heeft; er verschijnt dan een portal-venster onderin je editor waarmee je naar dat bestand springt.

De truc om betere suggesties te krijgen

Dit staat letterlijk in Cursors eigen troubleshooting-documentatie en het is het nuttigste zinnetje op die pagina: "Tab builds context from your recent edits and the code around your cursor." Wil je betere suggesties, maak dan eerst zelf een of twee handmatige bewerkingen die de richting laten zien. Hernoem de eerste variabele met de hand, verander het eerste veld in het patroon dat je wilt, en laat Tab de rest afmaken. Beginnen met een leeg bestand en hopen dat Tab je gedachten leest, is de manier waarop de meeste mensen teleurgesteld raken.

Tab per bestandstype uitzetten

Rechtsonder in je statusbalk staat een Tab-indicator. Daarmee kun je Tab tijdelijk snoozen, globaal uitzetten, of uitzetten voor specifieke bestandstypen. Dat laatste is de instelling die niemand kent en die veel oplevert: als je in markdown- of yaml-bestanden voortdurend ongewenste suggesties krijgt, zet je Tab daar uit en houd je hem aan in je code. De sneltoets zelf is herbindbaar; zoek in Keyboard Shortcuts op "Accept Cursor Tab Suggestions".

Op het gratis plan is Tab eindig

Belangrijk voor wie het uitprobeert: het gratis Hobby-plan heeft een maandelijkse Tab-toewijzing. Cursor schrijft: "Free (Hobby) users have a monthly Tab allowance. Once it's used up, suggestions pause until the next billing cycle." Stoppen je suggesties opeens zonder foutmelding, dan is dat de eerste plek om te kijken. Wat elk plan precies bevat, staat op modellen en prijzen.

Agent

De Agent: wat hij zelfstandig doet en waar de grenzen liggen

De officiele naam is Cursor Agent en je opent hem met Cmd + I in het zijpaneel. Cursors eigen definitie: "Agent is Cursor's assistant that can complete complex coding tasks independently, run terminal commands, and edit code." Het woord independently is geen marketing. De documentatie stelt expliciet: "There is no limit on the number of tool calls Agent can make during a task." Een agent kan dus tientallen bestanden lezen, een testsuite draaien, de uitkomst lezen en opnieuw beginnen, zonder dat jij ertussen zit.

Waaruit een agent bestaat

De documentatie ontleedt de Agent in drie componenten, en dat is een nuttiger model dan "het is AI". Ten eerste instructions: de systeemprompt plus jouw rules. Ten tweede tools: de lijst hierboven. Ten derde het model dat je kiest. Werkt de Agent niet zoals je wilt, dan zit de oorzaak vrijwel altijd in een van die drie. Verkeerde of ontbrekende rules, een tool die geblokkeerd is door je run mode of je .cursorignore, of een model dat te licht is voor de taak. Dat maakt foutzoeken bij agentic coding een stuk minder mystiek.

Checkpoints: handig, maar geen versiebeheer

De Agent maakt automatisch snapshots van je codebase tijdens een sessie. Je kunt via de chattijdlijn terug naar elk punt: hover over een eerder bericht en klik rechtsonder op Restore Checkpoint om alles terug te draaien wat de Agent daarna heeft gedaan. Lees hier wel de waarschuwing die Cursor er zelf bij zet: "Checkpoints are stored locally and separate from Git. Only use them for undoing Agent changes; use Git for permanent version control." Dus commit voordat je een agent op een grote taak loslaat. Een checkpoint is een ongedaan-maken-knop, geen back-up.

Berichten in de wachtrij zetten

Je hoeft niet te wachten tot de Agent klaar is. Terwijl hij werkt kun je vervolginstructies in de wachtrij zetten, ze herordenen door te slepen, en desgewenst direct doorduwen. De sneltoetsreferentie noemt Ctrl + Return voor "queue message" en Cmd + Return voor "force send message", waarbij Return standaard een nudge geeft. Praktisch gezien: zie je hem de verkeerde kant op gaan, dan corrigeer je direct in plaats van te wachten en achteraf terug te draaien.

Waar de grenzen liggen

Drie harde grenzen die je moet kennen. Ten eerste kan de Agent niets zien wat in je .cursorignore staat, en dat is de meest voorkomende reden waarom hij "een bestand niet kan vinden" dat er gewoon is. Ten tweede blijven sommige handelingen altijd goedkeuring vragen, ook in de meest permissieve run mode: de browsertool, het verwijderen van bestanden en wijzigingen aan bestanden buiten je workspace. Ten derde is de Agent afhankelijk van je index: is die verouderd, dan werkt hij op een oud beeld van je project. Cursor adviseert dan letterlijk om te herindexeren via het commandopalet met "Reindex".

Een detail dat builds sloopt

Cursor zet bij agent-commando's de omgevingsvariabele CI=1. Dat is bewust, want het voorkomt dat een script om invoer gaat vragen die de agent niet kan geven. Maar het betekent ook dat je project zich anders kan gedragen dan wanneer jij het commando zelf typt: prompts worden overgeslagen, CI-specifieke paden worden gekozen. Cursors eigen oplossing is het commando voorafgaan door unset CI, of die instructie in je rules zetten. Zoek je een verschil tussen "werkt bij mij" en "werkt bij de agent", begin hier.

Modi

Vier modi: Agent, Plan, Ask en Debug

Het chatvenster heeft niet een stand maar meerdere. Je wisselt ertussen met Shift + Tab vanuit het invoerveld, of via het modusmenu (Cmd + punt) en de dropdown in het Agent-paneel. Welke modus aanstaat bepaalt of Cursor mag schrijven, of hij eerst nadenkt, en of hij logregels in je code plaatst. De meeste frustratie met Cursor komt voort uit werken in de verkeerde modus.

Plan mode: eerst het gesprek, dan de code

Plan mode is de functie met de grootste opbrengst per seconde leerkosten. Je drukt Shift + Tab, beschrijft wat je wilt, en de Agent stelt eerst verhelderende vragen, onderzoekt je codebase en levert een implementatieplan op dat je kunt lezen en bijstellen voordat er ook maar een regel verandert. Cursor beveelt het expliciet aan bij taken met meerdere mogelijke aanpakken, werk dat veel bestanden raakt, vage eisen en architectuurkeuzes die je vooraf wilt beoordelen. Voor routineklussen kun je gewoon in Agent-modus beginnen.

Waar je plannen belanden, en waarom dat telt

Standaard worden plannen opgeslagen in je home directory, dus buiten je project. Met de knop "Save to workspace" verplaats je ze naar je repository. Doe dat, want dan staat het plan in versiebeheer, kan je collega het lezen, en heb je later documentatie van waarom een keuze zo gemaakt is. Dit is precies het soort ding dat een team onderscheidt van iemand die in zijn eentje prompt.

Ask mode: de veiligste manier om een codebase te leren kennen

Ask is alleen-lezen. De Agent analyseert en legt uit, maar wijzigt niets. Cursor geeft er zelf voorbeeldvragen bij die precies de eerste week van een nieuwe collega beschrijven: hoe werkt de authenticatiestroom, wat doet deze functie, waar wordt de databaseverbinding geconfigureerd, leg de relatie tussen deze twee modules uit. Voor Nederlandse teams die iemand laten inwerken op een oude codebase is dit een sterkere use case dan code genereren, en het risico is nul.

Debug mode: de modus die bijna niemand gebruikt

Dit is geen "vraag de AI waarom het stuk is". Debug mode voert een vaste procedure uit. De Agent verkent de relevante bestanden en formuleert hypotheses over de oorzaak. Dan plaatst hij logregels die naar een lokale debugserver sturen. Vervolgens reproduceer jij de bug volgens de stappen die hij aangeeft. Hij leest de verzamelde logs, bepaalt de werkelijke oorzaak, maakt een gerichte fix, verifieert die en verwijdert daarna zijn eigen instrumentatie weer. Cursor noemt als beste toepassingen: bugs die je kunt reproduceren maar niet kunt verklaren, race conditions en timingproblemen, prestatieproblemen en geheugenlekken, en regressies in code die het eerder wel deed. Je bereikt hem via de modusdropdown of Shift + Tab.

Inline edit

Inline edit en chat: kleine ingrepen zonder het chatpaneel

Niet elke wijziging verdient een agent. Voor een gerichte ingreep in code die je al voor je hebt, is inline edit sneller. De officiele naam is inline edit en de sneltoets is Cmd + K op Mac, Ctrl + K op Windows en Linux.

Zo gebruik je het

Selecteer de code, druk Cmd + K, typ je instructie en druk Return. Het voorbeeld uit de documentatie: "Convert this to an async function." Je kunt daarna gewoon doorvragen met een vervolginstructie. Het punt van inline edit is dat je context houdt: je ziet de code waar het over gaat, en je hoeft niet uit te leggen welk bestand je bedoelt.

De vraagmodus die verstopt zit achter Opt + Return

Binnen inline edit kun je omschakelen naar vragen in plaats van bewerken. Druk na Cmd + K op Opt + Return (Mac) of Alt + Return (Windows en Linux) en stel je vraag. Bevalt het antwoord en wil je het alsnog toepassen, typ dan letterlijk "do it" en druk Return. Dat is een van de kleine dingen die in geen enkele Nederlandse tutorial staat en die je dagelijks gebruikt zodra je het weet.

Doorschakelen naar de Agent

Blijkt de wijziging groter dan gedacht en raakt hij meerdere bestanden, dan schakel je door: selecteer de code en druk Cmd + L (Mac) of Ctrl + L (Windows en Linux). Dat opent de Agent met je selectie als context. De vuistregel is simpel: inline edit voor wat binnen je scherm past, de Agent voor alles wat daarbuiten gevolgen heeft.

Ook je terminal heeft Cmd + K

Weinig mensen weten dit: in het terminalvenster van Cursor opent Cmd + K een promptbalk waarin je in gewone taal beschrijft welk commando je zoekt. Cmd + Return draait het gegenereerde commando, Escape accepteert het zodat je het zelf nog kunt aanpassen. Voor iedereen die nooit onthoudt hoe de argumenten van ffmpeg, tar of awk ook alweer heten, is dat een dagelijkse tijdwinst.

Rules

Rules: projectafspraken vastleggen zodat de AI ze elke keer volgt

Dit is de functie die het verschil maakt tussen een leuke demo en bruikbaar teamwerk. Cursor legt zelf uit waarom rules bestaan: "Large language models don't retain memory between completions. Rules provide persistent, reusable context at the prompt level." Elke nieuwe chat begint met een leeg hoofd. Rules zijn de manier waarop je afspraken over codestijl, mappenstructuur, verboden libraries en reviewnormen elke keer opnieuw meegeeft zonder ze te typen.

De fout die iedereen een keer maakt

Project rules zijn .mdc-bestanden, geen .md-bestanden. De documentatie is daar onverbiddelijk over: "A plain .md file in .cursor/rules is ignored by the rules system because it has no frontmatter to specify description, globs, and alwaysApply." Zet je een gewoon markdownbestand in die map, dan gebeurt er niets en krijg je geen waarschuwing. Wil je toch gewoon markdown, gebruik dan AGENTS.md in je projectroot; dat is de officieel ondersteunde eenvoudige variant, en Cursor ondersteunt inmiddels ook geneste AGENTS.md-bestanden in submappen waarbij de meest specifieke voorrang krijgt.

De drie frontmattervelden

Bovenaan elk .mdc-bestand staan drie velden. description vertelt de Agent waar deze regel over gaat, zodat hij zelf kan bepalen of hij relevant is. globs koppelt de regel aan bestandspatronen, bijvoorbeeld alles in een componentenmap. alwaysApply is een booleaanse waarde die de regel in elke sessie meestuurt. Die drie velden bepalen samen welke van de vier toepassingstypen je krijgt.

De vier toepassingstypen

Always Apply gaat mee in elke chatsessie; gebruik dit spaarzaam, want alles wat altijd meegaat vult je contextvenster. Apply Intelligently laat de Agent op basis van de description besluiten of de regel nodig is; dat vraagt dus een goede description. Apply to Specific Files hangt aan een globpatroon en gaat automatisch mee als je aan die bestanden werkt. Apply Manually gaat alleen mee als je hem oproept met een @-vermelding, bijvoorbeeld @my-rule. Voor de meeste teams is de combinatie van een korte Always Apply-regel met de huisstijl plus een handvol globgebonden regels per domein de juiste opzet.

Wat je er concreet in zet

Denk niet aan "wees behulpzaam" maar aan de dingen die je bij een code review drie keer per week zegt. Welke pakketmanager je gebruikt. Dat er geen nieuwe dependencies bij mogen zonder overleg. Welke testfrontend je gebruikt en waar tests staan. Dat foutmeldingen naar de gebruiker in het Nederlands zijn en logregels in het Engels. Welke mappen af zijn en niet aangeraakt mogen worden. Dat is context engineering in zijn meest praktische vorm, en het scheelt meer herwerk dan welke modelkeuze ook.

Team Rules: een regel voor iedereen, zonder pull request

Op Teams- en Enterprise-plannen beheer je regels centraal vanuit het dashboard. Dat is het verschil tussen hopen dat iedereen dezelfde .cursor/rules heeft gepulld en het gewoon afdwingen. Voor een organisatie met meerdere repositories is dit de plek waar je beveiligingsafspraken en compliance-instructies zet.

Context

Context: het @-symbool, de index en wat je juist niet moet meegeven

Cursor kan alleen goed werk leveren over code die hij ziet. Er zijn twee manieren waarop hij die te zien krijgt: jij wijst hem aan met het @-symbool, of hij zoekt zelf in de index van je project. Beide hebben een eigen moment, en het populaire advies "geef altijd zo veel mogelijk context" is aantoonbaar verkeerd.

Wanneer je juist niets moet aanwijzen

Dit staat letterlijk in de officiele documentatie en het is contra-intuitief: "If you're not sure which files matter, skip it, Agent finds relevant files through its own search." Gebruik @ als je zeker weet welke bestanden relevant zijn, bijvoorbeeld een component samen met zijn testbestand. Weet je het niet, laat het dan aan de Agent. Half goed geraden context is slechter dan geen context, want je stuurt hem dan actief de verkeerde kant op.

De contextring: de meter die niemand aanklikt

In het chatvenster zit een contextring die laat zien hoe vol je tokenvenster zit. Klik erop en je krijgt een uitsplitsing per categorie: systeemprompt, tools, rules, gesprek. Dat is de snelste manier om te zien waarom een sessie duurder of trager wordt dan verwacht. Zie je dat rules of tools een groot deel opeten, dan weet je meteen waar je moet snoeien. Wat een token precies is en waarom dit geld kost, staat op modellen en prijzen.

Hoe Cursor zelf zoekt: Instant Grep en de Explore-subagent

Voor exacte zoekopdrachten gebruikt de Agent Instant Grep, een eigen zoekmachine waarvan Cursor claimt dat die "outperforms ripgrep on large codebases", met volledige regex- en woordgrensondersteuning. Daarnaast is er semantisch zoeken op basis van embeddings. En er is een Explore-subagent die in een eigen contextvenster met een sneller model veel parallelle zoekopdrachten uitvoert en alleen de relevante bevindingen teruggeeft. Dat laatste is de reden dat je hoofdgesprek niet volloopt terwijl de Agent tientallen bestanden doorneemt.

Meer dan tekst: schermafbeeldingen, spraak en modelwissels

Cursors eigen promptingdocumentatie noemt drie dingen die de meeste mensen niet gebruiken. Je kunt afbeeldingen in de chat slepen of een schermafbeelding plakken met Cmd + V, wat de snelste manier is om een ontwerp of een foutmelding over te brengen zonder hem over te typen. Je kunt dicteren via het microfoonicoon en de transcriptie nakijken voordat je verstuurt. En je kunt midden in een gesprek van model wisselen met Cmd + / of de modelkiezer, bijvoorbeeld een snel model voor de verkenning en een zwaarder model voor het redeneerwerk.

Wat je juist afschermt: .cursorignore

Met een .cursorignore in je projectroot, met dezelfde syntax als .gitignore, blokkeer je bestanden voor Agent, Tab, inline edit en @-verwijzingen. Met .cursorindexingignore haal je bestanden alleen uit de index terwijl ze wel bruikbaar blijven. Standaard negeert Cursor al alles uit je .gitignore plus een ingebouwde lijst met lockfiles, .env-bestanden, binaries, media, node_modules, __pycache__ en build-mappen. Cursor beveelt als globale patronen aan: /.env, /.env.*, /credentials.json, /secrets.json, **/*.key, **/*.pem en **/id_rsa. Lees wel de twee voorbehouden die Cursor er zelf bij zet, want ze zijn belangrijk: "While Cursor blocks ignored files, complete protection isn't guaranteed due to LLM unpredictability" en "The terminal and MCP server tools used by Agent cannot block access to code governed by .cursorignore". Een .cursorignore is dus hygiene, geen beveiligingsmaatregel. De volledige AVG-kant staat op privacy en zakelijk gebruik.

Terminal

Terminalintegratie en run modes: hoeveel je de agent laat doen

Cursor draait shell-commando's rechtstreeks in je terminal. Wanneer een commando meteen loopt, wanneer Cursor eerst toestemming vraagt en wanneer het in een sandbox belandt, bepaal je met je Run Mode. Dit is de belangrijkste veiligheidsinstelling in de hele applicatie en de meeste mensen kijken er nooit naar.

Wat de sandbox blokkeert

De sandbox laat commando's binnen je project werken maar legt drie beperkingen op: het lezen van beschermde bestanden zoals .git/config en .vscode, schrijven buiten goedgekeurde mappen, en netwerkverkeer, dat standaard geblokkeerd is. Op macOS draait dit op Seatbelt vanaf versie 2.0 en is er geen installatie nodig. Op Linux heb je kernel 6.2 of hoger nodig met Landlock v3 en unprivileged namespaces ingeschakeld. Dat laatste is een reeel obstakel op oudere bedrijfsimages, dus controleer het voordat je een uitrol plant.

Twee configuratiebestanden die je eenmalig instelt

In permissions.json leg je vast welke calls Auto-review automatisch mag draaien en welke langs review moeten. Het kent allow_instructions en block_instructions in gewone taal; Cursors eigen voorbeeld van een blokkeerinstructie is "Every AWS CLI command should go through approval first." In sandbox.json bepaal je tot welke netwerkdomeinen, lees- en schrijfpaden en tijdelijke mappen sandboxed commando's toegang hebben. Beide bestanden bestaan op gebruikersniveau in ~/.cursor/ en op projectniveau, en teamconfiguratie overschrijft lokale instellingen.

Wat altijd om goedkeuring vraagt

Ook in de meest permissieve modus houdt Cursor drie handelingen achter een prompt: het uitvoeren van de browsertool, het verwijderen van bestanden, en het aanpassen van bestanden buiten je workspace. Dat is een verstandige ondergrens, en het is goed om te weten dat die er is voordat je iemand met Run Everything laat werken. Voor de rest geldt de eerlijke waarschuwing die Cursor zelf bij de classifier zet: "The classifier can make mistakes."

Als je terminaluitvoer er raar uitziet

Zware shell-thema's zoals Powerlevel9k en Powerlevel10k kunnen de inline terminaluitvoer verstoren, met afgekapte of vervormde weergave als gevolg. Cursor zet daarom de omgevingsvariabele CURSOR_AGENT, zodat je in je .zshrc of .bashrc kunt detecteren dat Cursor draait en je thema kunt overslaan. Twee regels in je shellconfiguratie, en het probleem is weg.

MCP

MCP: Cursor koppelen aan je eigen systemen

Het Model Context Protocol is de open standaard waarmee AI-assistenten met externe systemen praten. Cursor ondersteunt het volledig. De officiele formulering is nuchter: MCP "enables Cursor to connect to external tools and data sources". In de praktijk betekent het dat je Cursor toegang geeft tot je issuetracker, je database, je designtool of je eigen interne API, zodat hij niet elke keer opnieuw hoeft te horen hoe je organisatie in elkaar zit.

Wat Cursor van het protocol ondersteunt

Niet elke client ondersteunt het hele protocol, dus dit is relevant als je zelf een MCP-server bouwt. Cursor ondersteunt Tools (functies die het model mag aanroepen), Prompts (sjabloonworkflows), Resources (gestructureerde databronnen), Roots (de server mag vragen naar URI's en bestandslocaties), Elicitation (de server mag de gebruiker om informatie vragen) en de Apps-uitbreiding, waarmee een MCP-tool een interactieve UI kan teruggeven.

Installeren: met een klik of met de hand

De makkelijkste route is de Cursor Marketplace via de Customize-pagina: bladeren en met een klik installeren. Wil je het zelf regelen, dan zet je een mcp.json neer waarin je per server een command met args en env opgeeft voor lokale servers, of een url met headers voor remote servers. Credentials geef je mee via omgevingsvariabelen. Voor remote servers met OAuth kun je statische client credentials meegeven, wat je nodig hebt bij aanbieders die geen Dynamic Client Registration doen of die een redirect-URL laten whitelisten.

Voor beheerders: dit is een aanvalsvlak

Een MCP-server die de Agent mag aanroepen, kan in principe alles wat die server kan. Cursor biedt daarom op Enterprise allowlists waarmee beheerders bepalen welke servers en welke tools een team mag uitvoeren, met aparte netwerkinstellingen voor lokale en remote servers. Houd daarnaast in gedachten wat we hierboven al noemden: MCP-tools vallen buiten je .cursorignore. Wie prompt injection serieus neemt, zet niet zomaar een MCP-server aan die willekeurige webinhoud binnenhaalt.

Verdieping: de volledige MCP-uitleg

MCP is groter dan Cursor en de concepten zijn overal hetzelfde: servers, tools, transporten, autorisatie en de risico's. We hebben dat uitgeschreven in een aparte gids die net zo goed van toepassing is als je met Cursor werkt: MCP uitgelegd, van server tot koppeling. Lees die als je van plan bent er zelf een te bouwen of er een van een derde partij aan te zetten in een zakelijke omgeving.

Uitbreiden

Skills, subagents, hooks en plugins: Cursor naar je hand zetten

Boven op rules en MCP zit een laag waarmee je Cursor daadwerkelijk programmeert. Je vindt alles bij elkaar op de Customize-pagina in de zijbalk, waar je per onderdeel kunt zien wat er actief is voor jou, je workspace of je team.

Agent Skills, en de verrassing in de mappenlijst

Agent Skills zijn draagbare, in versiebeheer opgeslagen pakketjes die een agent leren hoe hij een specifieke taak uitvoert, inclusief scripts, sjablonen en referentiemateriaal. Elke skill heeft een SKILL.md met frontmatter waarin name en description verplicht zijn, plus optioneel paths, disable-model-invocation en metadata. Cursor laadt skills automatisch uit .agents/skills/, .cursor/skills/, ~/.agents/skills/ en ~/.cursor/skills/. En hier zit het detail dat vergelijkingsartikelen missen: voor compatibiliteit laadt Cursor ook skills uit de mappen van de concurrentie, namelijk de .claude- en .codex-varianten. Heb je al skills geschreven voor Claude Code of Codex, dan werken die dus gewoon. Aanroepen doe je met / in de chat. Cursor levert er zelf een reeks mee, waaronder /review, /automate, /canvas, /shell en /split-to-prs.

Subagents: werk uitbesteden zonder je gesprek te vervuilen

Een subagent is een gespecialiseerde assistent met een eigen contextvenster. Cursor heeft er drie ingebouwd die automatisch worden ingezet bij contextzware bewerkingen: Explore doorzoekt en analyseert je codebase met een sneller model, Bash draait reeksen shell-commando's en houdt de uitvoerige uitvoer buiten je gesprek, en Browser bedient de browser en filtert de rommelige DOM-snapshots weg. Zelf maken doe je met een markdownbestand in .cursor/agents/ met frontmattervelden name, description, model (bijvoorbeeld "inherit"), readonly en is_background. Aanroepen kan expliciet met /naam of gewoon in gewone taal. Een grens om te kennen: nesting gaat een niveau diep. Een subagent mag zelf subagents starten, maar een subagent die door een subagent is gestart kan dat niet meer.

Hooks: de laag voor teams met beleid

Hooks zijn subprocessen die via JSON over stdin en stdout communiceren en draaien voor of na vaste momenten in de agentlus. Cursor noemt zelf als toepassingen: formatters draaien na een bewerking, analytics toevoegen, scannen op secrets en persoonsgegevens, risicovolle handelingen tegenhouden, subagents afknijpen en context injecteren bij het starten van een sessie. De lijst met gebeurtenissen is lang en dekt sessionStart en sessionEnd, preToolUse en postToolUse, beforeShellExecution en afterShellExecution, beforeMCPExecution en afterMCPExecution, beforeReadFile en afterFileEdit, beforeSubmitPrompt, preCompact, stop en meer, plus aparte hooks voor Tab en voor het openen van een workspace. Je configureert ze in .cursor/hooks.json in je project of ~/.cursor/hooks.json voor jezelf. Voor een Nederlandse organisatie die wil kunnen aantonen dat er gescand wordt op persoonsgegevens voordat een prompt de deur uitgaat, is dit de plek waar dat technisch geregeld wordt.

Plugins: alles in een pakket, ook voor je eigen organisatie

Een plugin bundelt rules, skills, agents, commands, MCP-servers en hooks tot een installeerbaar pakket. Je installeert ze via de Customize-pagina of de Cursor Marketplace, waar plugins een handmatige securityreview doorlopen voordat ze worden opgenomen. Zelf bouwen doe je met een map met een .cursor-plugin/plugin.json-manifest, die je lokaal test in ~/.cursor/plugins/local. Teams en Enterprise kunnen een eigen private marketplace opzetten met installatiemodi Default Off, Default On of Required, en toegang regelen via organisatiegroepen. Dat is de schaalbare manier om te zorgen dat vijftig developers echt dezelfde werkwijze gebruiken.

Verstopt

Negen functies die de meeste gebruikers nooit vinden

Dit zijn de functies waarvan we bij trainingen merken dat vrijwel niemand ze kent, terwijl ze allemaal in de officiele documentatie staan. Ze zitten achter een sneltoets, een slash-commando of een tabblad dat je nooit aanklikt.

Beperkingen

Waar Cursor tekortschiet

Geen enkele toolgids is compleet zonder dit hoofdstuk, en de meeste Engelstalige pagina's laten het weg. Hieronder staan de beperkingen die we tegenkomen bij bedrijven die Cursor uitrollen, met waar mogelijk Cursors eigen formulering erbij. Ze zijn geen reden om het niet te gebruiken, ze zijn de dingen waar je op moet plannen.

1. Het model verzint dingen, en Cursor zegt dat zelf

Cursors eigen lesmateriaal is hier opvallend eerlijk over. "Hallucination is when an AI model confidently generates information that seems plausible but is actually incorrect." En: "When an AI model doesn't know something, it doesn't always say I don't know. Instead, it generates what seems most likely based on patterns it has seen." Ze noemen drie concrete vormen in code: het verzinnen van API-methodes, het door elkaar halen van syntax uit verschillende frameworks, en het uitvinden van configuratieopties die niet bestaan. Daarbovenop komt het kennisafkappunt van het model: vraag je naar een library die daarna is uitgekomen, dan krijg je een plausibel maar fout antwoord. Cursors advies is precies wat wij ook adviseren: "Every suggestion is a starting point, not a final answer." Zie ook hallucinatie.

2. Je extensies komen niet uit de Microsoft-marktplaats

Cursor is een fork van VS Code, maar haalt extensies uit de Open VSX-registry en niet uit de Microsoft VS Code Marketplace. Niet alles staat daar. Cursor publiceert eigen, geauditeerde Anysphere-builds als vervanging voor een aantal veelgebruikte extensies, maar geeft zelf ook een waarschuwing die je moet lezen voordat je iets installeert: "The same publisher.extension name can point to different publishers or code on Open VSX than on the Microsoft Marketplace. Treat extension IDs like dependencies: install from publishers you trust." Hoeveel extensies precies ontbreken publiceert Cursor niet, dus we noemen daar geen getal bij. Wat je wel weet: als jouw team op een specifieke Microsoft-extensie leunt, controleer je dat voordat je overstapt.

3. Cursor loopt bewust achter op VS Code

Uit de migratiedocumentatie: "We regularly rebase Cursor onto the latest VS Code version to stay current with features and fixes. To ensure stability, Cursor often uses slightly older VS Code versions." Dat is een verdedigbare keuze, maar het betekent wel dat een nieuwe VS Code-functie of -fix niet meteen bij jou landt. Voor de meeste teams is dat irrelevant. Werk je met een extensie of taalserver die een recente VS Code-versie vereist, dan is het dat niet.

4. Extensies en zware projecten kosten prestaties

De officiele troubleshooting-pagina noemt drie klachten die je zult herkennen: hoog CPU- of geheugengebruik, traag indexeren en vertraging bij het typen. De genoemde oorzaken zijn steevast hetzelfde: extensies, en grote gegenereerde mappen die meegeindexeerd worden. De adviezen zijn concreet: draai cursor --disable-extensions om te testen en zet ze daarna een voor een terug aan, en zet mappen als dist/, build/ en .next/ in je .cursorignore. Extensies die zelf AI-aanvullingen leveren of sneltoetsen onderscheppen, waaronder andere AI-codeassistenten, zijn volgens Cursor de belangrijkste bron van conflicten.

5. Er zijn foutmeldingen die niets met AI te maken hebben

Twee die je gaat tegenkomen. "Agent Execution Timed Out" betekent volgens Cursor dat de extension host niet binnen 60 seconden was opgestart, waardoor de agentfuncties niet konden initialiseren; op beheerde bedrijfslaptops is endpoint-securitysoftware daar een bekende oorzaak van. En verdwijnen je Tab-suggesties op een bedrijfsnetwerk, dan kan HTTP/2 geblokkeerd zijn: Cursor heeft daar een instelling voor, HTTP Compatibility Mode, die terugvalt op HTTP/1.1, met een herstart erna. Beide zijn IT-problemen, geen AI-problemen, en beide kosten een dag als je ze niet kent.

6. .cursorignore is geen slot

We noemden het al bij context, maar het hoort ook hier, want mensen bouwen er beleid op. Cursor zegt zelf: "While Cursor blocks ignored files, complete protection isn't guaranteed due to LLM unpredictability" en "The terminal and MCP server tools used by Agent cannot block access to code governed by .cursorignore". Een agent die een shell-commando mag draaien kan dus in principe bij bestanden die je in .cursorignore hebt gezet. Wie echt gevoelige gegevens buiten bereik wil houden, haalt ze uit de repository of gebruikt run modes en sandboxinstellingen, niet alleen een ignore-bestand.

7. De reviewlaag kan het mis hebben

De Auto-review-modus stuurt onbekende commando's langs een classifier die beslist of ze mogen draaien. Cursor zet er zelf bij: "The classifier can make mistakes." Datzelfde geldt voor Bugbot en Agent Review: dat zijn extra ogen, geen goedkeuringsinstantie. Een menselijke reviewer blijft nodig, zeker bij securitygevoelige wijzigingen. Dat is precies waarom wij human in the loop als uitgangspunt hanteren en niet als optionele extra.

8. Sandboxing werkt niet overal even goed

Op macOS regelt Seatbelt het zonder installatie. Op Linux heb je kernel 6.2 of hoger nodig met Landlock v3 en unprivileged namespaces ingeschakeld. Op een verouderd bedrijfsimage of een gehardende Linux-installatie kan die combinatie ontbreken, en dan valt je belangrijkste veiligheidslaag weg. Controleer dat voordat je Auto-review als bedrijfsstandaard afkondigt. Voor Windows staat er in de documentatie die we hebben gelezen geen expliciete platformvereiste bij, dus daar doen we geen bewering over.

9. Voor Europese organisaties: de dataresidentie is niet EU

Dit valt buiten de functies, maar het bepaalt of je die functies mag gebruiken. Cursor biedt op dit moment alleen dataresidentie in de Verenigde Staten. Voor Europa is er uitsluitend inference-only dekking voor de EU plus IJsland, op aanvraag, en bredere EU-ondersteuning is volgens Cursor "in active development" zonder datum. Wat dat betekent voor je verwerkersovereenkomst, je DPIA en je verwerkingsregister, en welke functies je als beheerder kunt afdwingen, hebben we uitgewerkt op privacy en zakelijk gebruik.

10. Wat we niet met zekerheid konden vaststellen

Drie punten die we bewust open laten in plaats van in te vullen. Cursor publiceert nergens minimale systeemeisen: geen RAM, geen CPU, geen minimale versie van macOS, Windows of Linux. Als een fork van VS Code ligt de ondergrens in de praktijk in dezelfde orde, maar dat is onze inschatting en geen officiele uitspraak. Ten tweede: de stabiele build was op 3 augustus 2026 versie 3.14.7 volgens Cursors eigen download-API, terwijl de changelog als laatste genummerde release 3.11 van 10 juli 2026 toont; wat er tussen die twee zit is niet als releasenotities gepubliceerd. Ten derde loopt de beschikbaarheid van sommige modellen in de EU achter op de rest van de wereld vanwege de meldplicht uit de EU AI Act; controleer de actuele status in je eigen account voordat je een model in je werkwijze opneemt.