Cursor 用戶真正會收藏的是精簡規則，而非 900 個 Skill 的 ZIP

I keep seeing the same pattern in this niche: a giant free dump of Claude Skills or Cursor rules gets stars, then dies in a Downloads folder nobody opens after context compression.

What people bookmark is smaller. One well-scoped .mdc. A filter they can restate in three lines. Not a 900-skill ZIP.

What survives compression

After a long session, Cursor (or any agent) loses the chat-shaped memory. Mega-prompts evaporate. A 900-file ZIP is theater unless each file has a job:

• alwaysApply: true for the tiny core that must survive every turn
• globs for stack rules that only matter on matching paths
• Skills for recurring jobs (PR review, release notes) — not for "everything"

The rule I see people actually copy is the boring one:

If I asked for a bug fix, do not refactor the folder structure "while you're here."

That belongs in alwaysApply. It costs real time when forgotten. It applies to almost every edit. It stays tiny.

Public builders in this niche keep repeating the same funnel lesson: pain posts + a single shareable rule file + Dev.to → GitHub convert better than "here's my ZIP." Hard-sell threads on a small account rarely close the sale alone. So ship the tiny file people can save.

The three-part filter

A rule earns always-on only if all three are true:

1. Forgetting it after compaction costs real time or money — security, anti-scope-creep, "re-read AGENTS.md after compression"
2. It applies to almost every edit — not just React forms or Spring controllers
3. It stays tiny — a few imperative lines, not a style-guide novel

Everything else waits for a glob. React forms / TanStack Query / zod boundaries. Spring controllers / Bean Validation / "no JPA entities in responses." Those matter — but not on every keystroke. After compression, a bloated always-on list gets quietly deprioritized anyway; the model still invents a second form library.

Re-check the list only when something expensive broke twice. Most weeks the tiny core stays put. The list grows when a new failure mode costs real time after compaction — then a rule graduates to always-on or gets demoted to a glob.

Why dumps still feel good (and still fail)

Breadth dumps optimize for GitHub stars and "I might need this someday." Repo-native memory is a priority queue, not a junk drawer.

Quantity-volume packs (50+ stacks, "every framework") and $1 cross-agent compilers are useful for format plumbing. They are not a decision filter for what must stay in context after compression. Stars ≠ sessions saved.

What I ship (and how it differs)

I open-sourced a free Starter: three always-on rules + one PR-review Skill. The paid layer is not "more files for the sake of more files."

Differentiation (honest cold-start):

Drop-in examples (copy into .cursor/rules/):

• Anti-scope: https://github.com/kangtai-cn/agent-memory-pack/blob/main/examples/anti-scope-creep-always-apply.mdc
• Re-read after compaction: https://github.com/kangtai-cn/agent-memory-pack/blob/main/examples/re-read-after-compaction-always-apply.mdc

No fabricated sales numbers. Early cold-start. The methodology posts are the product proof until the checkout proves it.

Try this before you buy anything

1. Install one tiny always-on rule (anti-scope + "re-read AGENTS.md after compaction")
2. Force a recovery after your next compression — open the rule + AGENTS.md before continuing
3. Only then decide whether a dual-stack React/Java pack is worth a coffee

If the tiny core doesn't save you a session, another mega-ZIP won't either. Save the filter. Glob the stack. Pay only when the dual-stack layer is the missing piece — not when someone waved a 900-file archive at you.

Related: alwaysApply filter post · amnesia post