Claude Skills vs Windsurf Rules og Memories sammenlignet

Windsurf gjorde noe ingen andre AI-editorer brydde seg om å gjøre: den ga agenten sin en notatbok og ba den ta sine egne notater. Regler du skriver selv, greit, alle verktøy har det nå. Men Cascade, Windsurfs agent, genererer også memories på egen hånd, midt i samtalen, uten å bli spurt. Jobb i et repo i en uke, og den bygger stille en privat modell av hvordan du liker at ting gjøres.

Claude-skills kommer fra den motsatte filosofien. Ingenting kommer inn i en skill med mindre en person skrev det, og ingenting aktiveres med mindre beskrivelsen fortjener det. Vi driver SkillProof, der vi installerer skills på en ren maskin og tester dem før vi lister dem, så vi lever på den eksplisitte siden av dette skillet. Vi skal likevel prøve å være rettferdige, fordi auto-memory-ideen fortjener mer enn en avfeiing.

Kort oppsummert: Windsurf rules er et solid alltid-på og glob-avgrenset instruksjonssystem, nært Cursors. Memories er den genuint nye delen: null-innsats-personalisering som forbedrer editoren jo lenger du bruker den. Skills vinner på portabilitet, medfølgende verktøy, arbeid som ikke er kode, og det faktum at du kan lese hvert ord av hva AI-en din har blitt lært. Hvis du lever helt inne i Windsurf, bruk rules for harde lover og la memories samle seg opp, men revider dem månedlig. Hvis Claude er en del av arbeidsflyten din et sted, hold din varige ekspertise i skills og behandle Windsurfs memory som en cache, ikke en sannhetskilde.

	Windsurf rules + memories	Claude skills
Format	Markdown i .windsurf/rules/, pluss auto-genererte memories per arbeidsområde	SKILL.md-mappe i ~/.claude/skills/ eller .claude/skills/
Trigger	Always On, glob, Model Decision, eller manuell @-omtale; memories dukker opp automatisk	Beskrivelsesmatch, avgjort av modellen
Hvem skriver det	Du skriver rules; Cascade skriver memories	Du, eller en forfatter du kan vurdere
Nyttelast	Ren tekst, med tak (rundt 6000 tegn per regelfil)	Instruksjoner pluss skript, maler, referansefiler
Portabilitet	Kun Windsurf	Claude Code, Claude Desktop, claude.ai, Agent SDK
Reviderbarhet	Rules ja; memories bare hvis du åpner panelet og ser	Alt på disk, diffbart, i versjonskontroll
Testkultur	Ingen	Stort sett ingen; vi tester våre

Hva Windsurf rules og memories faktisk er

Windsurf deler vedvarende kontekst i to systemer som dokumentasjonen deres grupperer under ett navn, Memories, noe som forvirrer alle. Verdt å skille dem.

Rules er markdown-filer du skriver. Prosjektregler lever i .windsurf/rules/, én fil per tema, og en global_rules.md gjelder på tvers av alle prosjekter. Hver fil har en aktiveringsmodus: Always On (injiseres i hver Cascade-forespørsel), Glob (kobles på når en matchende fil er i kontekst, så *.tsx-regler blir med under React-arbeid), Model Decision (Cascade leser en beskrivelse du gir og bestemmer), og Manual (kun når du @-omtaler den). Filer har et tak på rundt 6000 tegn hver med et kombinert budsjett på tvers av globale og arbeidsområde-regler, så Windsurf forteller deg direkte at dette innholdet ligger i prompten og at lengde har en pris.

Hvis du har lest Cursor-sammenligningen vår, bør dette høres kjent ut. De fire modusene mappes nesten én-til-én på Cursors, og analysen av always-on- og glob-triggering overføres uendret.

Memories er delen uten noen Cursor-ekvivalent. Mens du jobber, bestemmer Cascade at noe er verdt å huske, «dette prosjektet bruker pnpm, ikke npm», «brukeren foretrekker early returns fremfor nøstede betingelser», og lagrer det som en memory avgrenset til arbeidsområdet. Du kan også be den huske noe eksplisitt. Memories vedvarer på tvers av økter, dukker opp automatisk når Cascade vurderer dem relevante, og koster ingen credits å generere. Det finnes et panel der du kan lese, redigere og slette dem, noe som får betydning senere.

Så den ærlige rammingen er ikke skills mot rules. Det er et eksplisitt, portabelt instruksjonsformat mot en hybrid: eksplisitte regler pluss et implisitt, selvskrivende memory-lag.

Der Windsurf genuint vinner

Auto-memories er en ekte innovasjon, og vi sier det rett ut. Det vanskeligste problemet med AI-instruksjonsfiler er at ingen skriver dem. Hvert team sier de skal dokumentere konvensjonene sine for agenten; nesten ingen gjør det, og filen som finnes er åtte måneder foreldet. Windsurf ruter helt rundt menneskelig latskap. Kunnskapen fanges som et biprodukt av å jobbe, i det øyeblikket den demonstreres. Etter noen uker vet Cascade hvilken testkjører du bruker, importstilen din, og den ene forbannede mappen ingen rører, og du skrev aldri et ord av det ned. Som svar på «hvordan blir denne kunnskapen i det hele tatt registrert», er det den beste noen editor har levert.

Null-oppsett-personalisering. En ny Windsurf-bruker får en progressivt smartere editor som standard. En ny Claude-skills-bruker får en tom mappe og en avgjørelse å ta. Vi skrev en full guide til skills delvis fordi formatet har en læringskurve; memories har ingen.

IDE-nativ rekkevidde. Rules og memories deltar i alt Windsurf gjør, inkludert inline-redigeringer og Cascades agentiske kjøringer, uten noe installasjonstrinn. Skills opererer der Claude opererer, som ikke inkluderer innsiden av en annen bedrifts editor.

Glob-presisjon. Samme poeng som med Cursor, og det står fortsatt: «koble på disse SQL-konvensjonene når en .sql-fil er i kontekst» er en mekanisk garanti. Skills tilnærmer seg det med beskrivelsesformulering, som modellen tolker godt, men ikke lover.

Der skills vinner

Gjenbruk på tvers av prosjekter og flater. En skill i ~/.claude/skills/ følger deg inn i hvert repo, og også inn i Claude Desktop og claude.ai. Din feilsøkingsdisiplin gjelder når du fikser en pipeline på jobb og når du fikler med et sideprosjekt på en søndag. Windsurf-memories er avgrenset til arbeidsområdet by design; pnpm-lærdommen fra prosjekt A må læres på nytt i prosjekt B. Globale regler finnes, men deler det stramme tegnbudsjettet.

Arbeid som ikke er kode. Windsurf er en IDE, og hele kontekstsystemet dens antar at det som jobbes med er et repository. Skills bryr seg ikke. Det samme formatet som lærer Claude commit-konvensjonene dine, lærer den også hvordan man strukturerer et salgsforslag eller rydder opp i en regnearkeksport. Halve katalogen vår har ingenting med programvare å gjøre.

Medfølgende verktøy. En regelfil, med tak på 6000 tegn, beskriver atferd. En skill-mappe leverer den. Anthropics docx-skill inkluderer Python-skript som bygger Word-dokumenter i stedet for prosa om hvordan man kunne gjort det. Skill-creator-skillen bærer maler og en evalueringsmotor. En systematic debugging-skill kan holde eskaleringssjekklisten sin i en referansefil som bare lastes midt i en undersøkelse. Progressiv avdekking er det som gjør dette rimelig: femti installerte skills ligger i dvale på noen få tusen tokens metadata, og det tunge materialet blir på disk til øyeblikket det trengs.

Et økosystem du kan revidere. En skill er filer. Du kan lese hver linje før installasjon, diffe den etter en oppdatering, og legge den i versjonskontroll ved siden av koden den styrer. Når en kollega spør hvorfor agenten formaterer migreringer på en bestemt måte, er svaret en fil med en git-historikk. Dette er også det som gjør tredjeparts-skills testbare i det hele tatt, og hvorfor kodesamlingen vår kan bære bestått/ikke-bestått-dommer i stedet for stjerneantall.

Migrering i begge retninger

Formatene er nære nok til at konvertering stort sett handler om å merke om. Her er en typisk Windsurf-prosjektregel:

---
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

Som en skill flytter trigger-metadataen inn i frontmatter Claude matcher mot, og du får rom til å vokse:

---
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.

Lagre den under .claude/skills/api-endpoint-conventions/SKILL.md. Beskrivelsen gjør jobben en triggermodus gjorde, så skriv den slik vi beskriver i triggerguiden vår: nevn oppgaven, nevn øyeblikket. Og nå kan feilkatalogen være en medfølgende referansefil i stedet for et offer for tegntaket.

Går du motsatt vei, ta kroppen av en skill, trim den under 6000 tegn, og velg den ærlige aktiveringsmodusen:

---
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

Det du mister i eksporten: medfølgende skript (regler kan ikke levere kjørbare filer), referansefiler, og alt over taket. Det du får: glob-tilkobling som utløses mekanisk, ingen modellvurdering involvert. Alt du lærte av å konvertere Copilots format, overføres hit også; den sammenligningen dekker applyTo-ekvivalenten.

Memories er den vanskelige resten. Det finnes ingen eksportknapp; de lever i Windsurfs egen lagring. Det praktiske grepet er å åpne Memories-panelet, lese hva Cascade skrev, og manuelt forfremme de gode til rules eller skills. Som bringer oss til den ubehagelige delen.

Auto-memory-problemet: ingen gjennomgår hva den har lært

Her er advarselen som hører hjemme i hver artikkel som roser auto-memories, og som dukker opp i nesten ingen av dem.

Cascade lærer av det du gjør, og det du gjør inkluderer feilene dine. Aksepter en slapp any-type klokken 18 en fredag, og memory-systemet har ingen måte å vite at det var overgivelse snarere enn preferanse. La den se deg hoppe over tester i en hotfix-uke, og «denne brukeren skriver ikke tester først» er en nøyaktig observasjon den kan stille generalisere. Systemet registrerer demonstrert atferd. Det kan ikke skille standardene dine fra glippene dine, fordi det bare noensinne ser glippene.

Det dypere problemet er gjennomgang, eller fraværet av det. Alle andre artefakter som former kodebasen din, passerer gjennom øyne: kode blir gjennomgått, avhengigheter skannes, konfigurasjoner lever i pull requests. Memories er skrevet av modellen, godkjent av ingen, og konsultert usynlig. Windsurf gir deg et panel for å inspisere dem, noe som genuint er til dens ære, og etter vår erfaring åpner omtrent ingen det. Når atferd driver, er årsaken en setning i et lager du glemte eksisterte.

Skills sitter i den andre enden, og dette er det filosofiske skillet som er verdt å velge på, mer enn noen funksjonssjekkliste. En skill er bevisst. Noen bestemte at denne kunnskapen var verdt å kode inn, skrev den ned, og kan bli spurt hvorfor. Den er reviderbar før installasjon, diffbar etter oppdateringer, kan lastes skylden på i git for alltid. Kostnaden er ærlig også: eksplisitt betyr arbeidskrevende, og arbeidskrevende betyr at mindre fanges opp. Windsurf satset på at å fange alt implisitt slår å fange mindre eksplisitt. For editor-komfort lønner det satset ofte seg. For alt du ville kalt ingeniørstandarder, vil vi ha versjonen med en forfatter.

Hvis du bruker Windsurf, bruk styrken dens og håndter risikoen: la memories samle seg opp, og sett så en månedlig ti-minutters revisjon i kalenderen. Slett de som memorerte den dårlige uken din. Forfrem de som fortjener det til rules, der de blir eksplisitte og synlige. Den ene vanen konverterer memory-systemet fra en sakte drift til en fangst-tratt, med noe som en memory management-skill som håndterer den samme disiplinen på Claude-siden.

To utestede økosystemer, én testevane

Delte rules og delte skills har den samme sykdommen: publisering uten verifisering. GitHub er vert for tusenvis av regelfiler og skills som ble skrevet én gang, stjernemerket, og aldri kjørt av noen andre enn forfatteren, hvis forfatteren i det hele tatt kjørte dem. Da vi begynte å installere community-skills på rene maskiner, feilet grovt regnet halvparten ved første forsøk, og det er ingen grunn til å tro at limte regelfiler klarer seg bedre. De feiler bare mer stille, fordi en regel som aldri hjelper ser identisk ut med en regel som aldri ble lest.

Auto-memories unngår dette spesifikke problemet, siden de genereres fra din egen atferd i stedet for lastes ned fra en fremmed. Et reelt poeng i deres favør, og den samme avveiningen igjen: memories tar aldri feil av hva du gjorde, bare av om du mente det.

Ofte stilte spørsmål

Kan jeg bruke Claude-skills inne i Windsurf? Ikke nativt. Cascade leser sine egne rules og memories, og skills er en Claude-konvensjon. Team som bruker begge, beholder som regel en delt regelfil for universelle prosjektlover og vedlikeholder skills for Claude Code-økter i samme repo. Mild duplisering, til å leve med hvis begge holdes korte.

Koster Windsurf-memories credits eller tokens? Å generere memories bruker ingen credits. Innholdet deres opptar derimot promptplass når Cascade henter dem frem, akkurat som rules, noe som er enda en grunn til å beskjære lageret innimellom.

Hvor lever Windsurf-rules kontra skills? Windsurf: .windsurf/rules/ i prosjektet, pluss en global_rules.md for alt. Claude: .claude/skills/<name>/SKILL.md per prosjekt, ~/.claude/skills/ globalt. Begge er ren markdown; bare skills kan bære ytterligere filer ved siden av seg.

Kan jeg eksportere Windsurf-memories til en skill? Det finnes ingen eksportfunksjon. Åpne Memories-panelet, kopier oppføringene verdt å beholde, og skriv dem inn i en SKILL.md med en beskrivelse som navngir når de gjelder. Ti minutters arbeid, og resultatet er versjonert og portabelt, noe memory-lageret ikke er.

Er en Windsurf-regel med model_decision det samme som en skill-trigger? Mekanisk likt: begge lar modellen lese en beskrivelse og bestemme. Forskjellene er hva som lastes etterpå (en tekstfil med tak versus en mappe med ressurser) og hvor avgjørelsen kan skje (inne i Windsurf versus hvor som helst Claude kjører).

Begge systemene prøver å løse det samme problemet fra motsatte ender: Windsurf ved å observere deg, skills ved å spørre deg. Å observere skalerer bedre. Å spørre aldres bedre. Vi vil heller vedlikeholde ti filer vi kan lese enn å stole på hundre observasjoner vi aldri har sett, og hvis det høres ut som et testlaboratoriums yrkesskjevhet, er det det. Det er også hvordan vi tok et halvt økosystem i å ikke virke.