Claude skills vs Windsurf rules & memories vergeleken

Windsurf deed iets waar geen enkele andere AI-editor de moeite voor nam: het gaf zijn agent een notitieblok en vertelde hem zijn eigen aantekeningen te maken. Rules die je zelf schrijft, prima, elke tool heeft die nu. Maar Cascade, Windsurfs agent, genereert ook zelf memories, midden in het gesprek, zonder erom gevraagd te worden. Werk een week in een repo en hij bouwt stilletjes een privémodel van hoe jij dingen graag gedaan ziet.

Claude skills komen uit de tegenovergestelde filosofie. Niets komt in een skill tenzij een mens het schreef, en niets activeert tenzij de beschrijving het verdient. We draaien SkillProof, waar we skills installeren op een schone machine en ze testen voordat we ze vermelden, dus we leven aan de expliciete kant van deze scheidslijn. We proberen toch eerlijk te zijn, want het auto-memory-idee verdient meer dan een afwijzing.

TL;DR: Windsurf rules zijn een solide altijd-aan en glob-geschaald instructiesysteem, dicht bij dat van Cursor. Memories zijn het echt nieuwe deel: zero-effort personalisatie die de editor verbetert hoe langer je hem gebruikt. Skills winnen op portabiliteit, gebundelde tooling, werk dat geen code is, en het feit dat je elk woord kunt lezen van wat je AI geleerd is. Als je volledig binnen Windsurf leeft, gebruik rules voor harde wetten en laat memories accumuleren, maar audit ze maandelijks. Als Claude ergens deel uitmaakt van je workflow, houd je duurzame expertise in skills en behandel je Windsurfs memory als een cache, niet als een bron van waarheid.

	Windsurf rules + memories	Claude skills
Formaat	Markdown in .windsurf/rules/, plus automatisch gegenereerde memories per workspace	SKILL.md-map in ~/.claude/skills/ of .claude/skills/
Trigger	Always On, glob, Model Decision, of handmatige @-vermelding; memories verschijnen automatisch	Beschrijving-match, bepaald door het model
Wie schrijft het	Jij schrijft rules; Cascade schrijft memories	Jij, of een auteur die je kunt controleren
Payload	Platte tekst, begrensd (ongeveer 6.000 tekens per rule-bestand)	Instructies plus scripts, templates, referentiebestanden
Portabiliteit	Alleen Windsurf	Claude Code, Claude Desktop, claude.ai, de Agent SDK
Controleerbaarheid	Rules ja; memories alleen als je het paneel opent en kijkt	Alles op schijf, diffbaar, in versiebeheer
Testcultuur	Afwezig	Grotendeels afwezig; wij testen de onze

Wat Windsurf rules en memories eigenlijk zijn

Windsurf splitst persistente context in twee systemen die de documentatie onder één naam groepeert, Memories, wat iedereen in verwarring brengt. Het loont om ze te scheiden.

Rules zijn markdown-bestanden die jij schrijft. Projectrules leven in .windsurf/rules/, één bestand per onderwerp, en een global_rules.md geldt voor alle projecten. Elk bestand draagt een activatiemodus: Always On (geïnjecteerd in elk Cascade-verzoek), Glob (koppelt wanneer een matchend bestand in context staat, dus *.tsx-rules rijden mee tijdens React-werk), Model Decision (Cascade leest een beschrijving die jij geeft en beslist), en Manual (alleen wanneer je er met @ naar verwijst). Bestanden zijn begrensd op ongeveer 6.000 tekens elk met een gecombineerd budget over globale en workspace-rules, dus Windsurf vertelt je direct dat deze inhoud in de prompt zit en lengte een prijs heeft.

Als je onze Cursor-vergelijking gelezen hebt, zou dit bekend moeten klinken. De vier modi mappen bijna één-op-één op die van Cursor, en de analyse van altijd-aan en glob-triggering geldt onveranderd.

Memories zijn het deel zonder Cursor-equivalent. Terwijl je werkt, besluit Cascade dat iets de moeite waard is om te onthouden, "dit project gebruikt pnpm, geen npm," "gebruiker geeft de voorkeur aan early returns boven geneste conditionals," en slaat het op als een memory geschaald naar de workspace. Je kunt hem ook expliciet vragen iets te onthouden. Memories blijven bestaan tussen sessies, verschijnen automatisch wanneer Cascade ze relevant acht, en kosten geen credits om te genereren. Er is een paneel waar je ze kunt lezen, bewerken en verwijderen, wat er later toe doet.

Dus het eerlijke frame is niet skills versus rules. Het is een expliciet, portabel instructieformaat versus een hybride: expliciete rules plus een impliciete, zelfschrijvende memory-laag.

Waar Windsurf echt wint

Auto-memories zijn een echte innovatie, en dat zeggen we ronduit. Het moeilijkste probleem bij AI-instructiebestanden is dat niemand ze schrijft. Elk team zegt dat ze hun conventies voor de agent zullen documenteren; bijna geen enkel doet het, en het bestand dat bestaat is acht maanden verouderd. Windsurf omzeilt menselijke luiheid volledig. De kennis wordt vastgelegd als bijproduct van het werken, op het moment dat hij gedemonstreerd wordt. Na een paar weken kent Cascade je testrunner, je importstijl, en die ene vervloekte map die niemand aanraakt, en jij hebt er geen woord van opgeschreven. Als antwoord op "hoe wordt deze kennis überhaupt vastgelegd," is het de beste die enige editor heeft geleverd.

Zero-setup personalisatie. Een nieuwe Windsurf-gebruiker krijgt standaard een progressief slimmere editor. Een nieuwe Claude skills-gebruiker krijgt een lege map en een beslissing te nemen. We schreven een volledige gids voor skills deels omdat het formaat een leercurve heeft; memories hebben er geen.

IDE-native bereik. Rules en memories doen mee aan alles wat Windsurf doet, inclusief inline edits en Cascades agentische runs, zonder installatiestap. Skills opereren waar Claude opereert, wat niet de binnenkant van de editor van een ander bedrijf omvat.

Glob-precisie. Hetzelfde punt als bij Cursor, en het staat nog steeds: "koppel deze SQL-conventies wanneer een .sql-bestand in context staat" is een mechanische garantie. Skills benaderen het met beschrijvingsformulering, wat het model goed interpreteert maar niet belooft.

Waar skills winnen

Cross-project, cross-oppervlak hergebruik. Een skill in ~/.claude/skills/ volgt je in elke repo, en ook in Claude Desktop en claude.ai. Je debug-discipline geldt wanneer je een pipeline op je werk repareert en wanneer je op zondag aan een side-project prutst. Windsurf-memories zijn ontworpen om workspace-geschaald te zijn; de pnpm-les geleerd in project A wordt herleerd in project B. Globale rules bestaan wel maar delen dat strakke tekenbudget.

Werk dat geen code is. Windsurf is een IDE, en zijn hele contextsysteem gaat ervan uit dat het bewerkte ding een repository is. Skills geven daar niet om. Hetzelfde formaat dat Claude je commitconventies leert, leert hem ook hoe een salesvoorstel te structureren of een spreadsheet-export op te schonen. De helft van onze catalogus heeft niets met software te maken.

Gebundelde tooling. Een rule-bestand, begrensd op 6.000 tekens, beschrijft gedrag. Een skill-map levert het. Anthropics docx-skill bevat Python-scripts die Word-documenten bouwen in plaats van proza over hoe je dat zou kunnen doen. De skill-creator-skill draagt templates en een eval-harness. Een systematic debugging-skill kan zijn escalatiechecklist in een referentiebestand houden dat alleen laadt tijdens een onderzoek. Progressive disclosure maakt dit betaalbaar: vijftig geïnstalleerde skills draaien stationair op een paar duizend tokens metadata, en het zware materiaal blijft op schijf tot het moment dat het nodig is.

Een ecosysteem dat je kunt controleren. Een skill is bestanden. Je kunt elke regel lezen voordat je installeert, diffen na een update, en het in versiebeheer zetten naast de code die het bestuurt. Wanneer een teamgenoot vraagt waarom de agent migraties op een bepaalde manier formatteert, is het antwoord een bestand met een git-geschiedenis. Dit is ook wat externe skills überhaupt testbaar maakt, en waarom onze coding-collectie pass/fail-verdicten kan dragen in plaats van sterrenaantallen.

Migreren in beide richtingen

De formaten liggen dicht genoeg bij elkaar dat conversie vooral herlabelen is. Hier is een typische Windsurf-projectrule:

---
trigger: model_decision
description: API endpoint conventions for this service
---

- All endpoints live in src/api/, one file per resource
- Validate request bodies with zod schemas from src/schemas/
- Return errors as { error: { code, message } }, never bare strings
- Every new endpoint needs a happy-path test and a 401 test

Als skill verhuist de trigger-metadata naar frontmatter waar Claude tegen matcht, en je krijgt ruimte om te groeien:

---
name: api-endpoint-conventions
description: Conventions for building or modifying API endpoints in this
  service. Use when creating routes, changing request/response shapes, or
  reviewing API code.
---

## Structure
All endpoints live in src/api/, one file per resource.
Validate request bodies with zod schemas from src/schemas/.

## Errors
Return errors as { error: { code, message } }, never bare strings.

## Tests
Every new endpoint needs a happy-path test and a 401 test.
See reference/error-codes.md for the full error catalog.

Sla het op onder .claude/skills/api-endpoint-conventions/SKILL.md. De beschrijving doet het werk dat een triggermodus deed, dus schrijf hem zoals we beschrijven in onze triggering-gids: benoem de taak, benoem het moment. En nu kan de foutcatalogus een gebundeld referentiebestand zijn in plaats van een slachtoffer van de tekenlimiet.

De andere kant op, neem de body van een skill, snoei hem onder 6.000 tekens, en kies de eerlijke activatiemodus:

---
trigger: glob
globs: "**/*.test.ts"
---

- Use vitest, never jest
- One describe block per exported function
- No snapshot tests for logic; snapshots are for markup only

Wat je verliest in de export: gebundelde scripts (rules kunnen geen executables verschepen), referentiebestanden, en alles voorbij de limiet. Wat je wint: glob-koppeling die mechanisch vuurt, geen modeloordeel erbij betrokken. Alles wat je leerde van het converteren van Copilots formaat gaat hier ook op; die vergelijking behandelt het applyTo-equivalent.

Memories zijn het lastige restant. Er is geen exportknop; ze leven in Windsurfs eigen opslag. De praktische zet is het Memories-paneel te openen, te lezen wat Cascade schreef, en de goede handmatig te promoveren naar rules of skills. Wat ons bij het ongemakkelijke deel brengt.

Het auto-memory-probleem: niemand controleert wat het leerde

Hier is de waarschuwing die in elk artikel hoort dat auto-memories prijst, en in bijna geen enkel voorkomt.

Cascade leert van wat je doet, en wat je doet omvat je fouten. Accepteer een lui any-type om 18:00 op een vrijdag en het memory-systeem heeft geen manier om te weten dat dat overgave was in plaats van voorkeur. Laat hem zien dat je tests overslaat tijdens een hotfix-week en "deze gebruiker schrijft geen tests vooraf" is een accurate observatie die hij stilletjes kan generaliseren. Het systeem legt gedemonstreerd gedrag vast. Het kan je standaarden niet onderscheiden van je uitglijders, omdat het alleen ooit de uitglijders ziet.

Het diepere probleem is review, of de afwezigheid daarvan. Elk ander artefact dat je codebase vormt, gaat door ogen: code wordt gereviewd, dependencies worden gescand, configs leven in pull requests. Memories worden geschreven door het model, goedgekeurd door niemand, en onzichtbaar geraadpleegd. Windsurf geeft je een paneel om ze te inspecteren, wat het echt tot zijn eer strekt, en naar onze ervaring opent vrijwel niemand het. Wanneer gedrag afdrijft, is de oorzaak een zin in een opslag die je vergat te bestaan.

Skills zitten aan het andere eind, en dit is het filosofische verschil dat de moeite waard is om op te kiezen, meer dan enige featurecheck. Een skill is opzettelijk. Iemand besloot dat deze kennis het waard was om vast te leggen, schreef het op, en kan gevraagd worden waarom. Het is controleerbaar voor installatie, diffbaar na updates, voor altijd te verwijten in git. De kost is ook eerlijk: expliciet betekent inspannend, en inspannend betekent minder wordt vastgelegd. Windsurf wedde dat alles impliciet vastleggen wint van minder expliciet vastleggen. Voor editorgemak betaalt die weddenschap vaak uit. Voor alles wat je engineering-standaarden zou noemen, willen wij de versie met een auteur.

Als je Windsurf gebruikt, gebruik zijn kracht en beheer zijn risico: laat memories accumuleren, plan dan een maandelijkse audit van tien minuten. Verwijder de exemplaren die je slechte week onthouden hebben. Promoveer de blijvers naar rules, waar ze expliciet en zichtbaar worden. Die ene gewoonte zet het memory-systeem om van een langzame drift naar een vastleg-trechter, met iets als een memory-management-skill die dezelfde discipline aan de Claude-kant behandelt.

Twee ongeteste ecosystemen, één testgewoonte

Gedeelde rules en gedeelde skills hebben dezelfde ziekte: publicatie zonder verificatie. GitHub host duizenden rule-bestanden en skills die één keer geschreven, met sterren beoordeeld, en nooit gedraaid zijn door iemand anders dan de auteur, als de auteur ze überhaupt draaide. Toen we begonnen met community-skills op schone machines te installeren, faalde ruwweg de helft bij de eerste poging, en er is geen reden om aan te nemen dat geplakte rule-bestanden het beter doen. Ze falen alleen stiller, omdat een rule die nooit helpt er identiek uitziet aan een rule die nooit gelezen is.

Auto-memories ontwijken dit specifieke probleem, aangezien ze gegenereerd worden uit jouw gedrag in plaats van gedownload van een vreemde. Een echt pluspunt in hun voordeel, en dezelfde ruil weer: memories hebben nooit ongelijk over wat je deed, alleen over of je het meende.

FAQ

Kan ik Claude skills gebruiken binnen Windsurf? Niet nativ. Cascade leest zijn eigen rules en memories, en skills zijn een Claude-conventie. Teams die beide gebruiken houden meestal een gedeeld rules-bestand aan voor universele projectwetten en onderhouden skills voor Claude Code-sessies in dezelfde repo. Milde duplicatie, draaglijk als beide kort blijven.

Kosten Windsurf-memories credits of tokens? Memories genereren kost geen credits. Hun inhoud neemt wel promptruimte in wanneer Cascade ze naar boven haalt, net als rules, wat nog een reden is om de opslag af en toe te snoeien.

Waar leven Windsurf rules versus skills? Windsurf: .windsurf/rules/ in het project, plus een global_rules.md voor alles. Claude: .claude/skills/<naam>/SKILL.md per project, ~/.claude/skills/ globaal. Beide zijn platte markdown; alleen skills kunnen extra bestanden ernaast dragen.

Kan ik Windsurf-memories exporteren naar een skill? Er is geen exporteur. Open het Memories-paneel, kopieer de vermeldingen die het bewaren waard zijn, en schrijf ze in een SKILL.md met een beschrijving die benoemt wanneer ze gelden. Tien minuten werk, en het resultaat is geversioneerd en portabel, wat de memory-opslag niet is.

Is een Windsurf-rule met model_decision hetzelfde als een skill-trigger? Mechanisch vergelijkbaar: beide laten het model een beschrijving lezen en beslissen. De verschillen zitten in wat daarna laadt (een begrensd tekstbestand versus een map met bronnen) en waar de beslissing kan plaatsvinden (binnen Windsurf versus overal waar Claude draait).

Beide systemen proberen hetzelfde probleem vanuit tegenovergestelde uiteinden op te lossen: Windsurf door je te observeren, skills door het je te vragen. Observeren schaalt beter. Vragen veroudert beter. Wij onderhouden liever tien bestanden die we kunnen lezen dan honderd observaties die we nooit gezien hebben, en als dat klinkt als de beroepsmatige bias van een testlab, dan is het dat ook. Het is ook hoe we een halve ecosysteem betrapten dat niet werkte.