Which Cursor rules deserve alwaysApply (and which should wait for a glob)

KANG TAI — Thu, 29 Oct 2026 02:21:33 +0000

Someone asked me: how do you decide which rules earn the always-on slot, and which can wait until a matching file shows up?

That's the real product question. Not "how many rules can I zip."

The wrong answer

Putting everything in alwaysApply: true.

You pay context rent every turn. After compaction, long or generic rules get quietly deprioritized anyway. The model still invents a second form library.

The filter I use

A rule earns alwaysApply only if all three are true:

It must survive compression — if the agent forgets it mid-session, you lose money or time (security, anti-scope-creep, "re-read AGENTS.md after compaction").
It applies to almost every edit — not just React forms or Spring controllers.
It stays tiny — a few imperative lines, not a style guide novel.

Everything else gets globs (or alwaysApply: false + a sharp description the agent can request).

Concrete split (React + Java repos)

Always-on (tiny core)

Anti-amnesia / session handoff: plan briefly, persist decisions on disk, re-read after compaction
Anti-scope-creep: if I asked for a bug fix, do not refactor the folder structure "while you're here"
Security baseline: no secrets in commits, no inventing auth bypasses

Globbed (stack layer)

React forms / TanStack Query / zod boundaries → **/*.{tsx,ts} under UI paths
Spring controllers / Bean Validation / no JPA entities in responses → **/controller/**/*.java, **/web/**/*.java
zod ↔ Bean Validation mapping → only when touching API contract files

Same methodology works if your stack is Next-only or Go — the filter is the product, not the file count.

Why free "900-skill dumps" still fail here

Breadth dumps optimize for GitHub stars. They don't decide what must stay in context after compression. Repo-native memory is a priority queue, not a junk drawer.

Try the tiny core first

I open-sourced a free Starter: three always-on rules + one PR-review Skill.

Landing + Starter: https://kangtai-cn.github.io/agent-memory-pack/?ref=devto-always-on

Full React/Java Bundle ($29 one-time): https://pancake.waffo.ai/store/facai-p8dgqpdw/product/PROD_3jvtO8nHvcOv2YPQSyOpzf?type=onetime&currency=USD&ref=devto-always-on

Install the Starter. After your next compaction, force a recovery from AGENTS.md. If that alone saves a session, the globbed pack is the upgrade — not another mega-ZIP.

No fabricated sales. Honest cold-start: methodology posts convert better than hard sell on a small account.

Your Cursor agent isn't dumb — it's amnesiac

KANG TAI — Thu, 29 Oct 2026 02:20:00 +0000

I used to blame the model when Cursor "forgot" that we use TanStack Query, zod at the boundary, and never return JPA entities from controllers. Then I watched a session survive a long refactor… until context compression. After that, the agent cheerfully invented a second data-fetching style and refactored three unrelated files "while it was here."

The model didn't get worse. The memory evaporated.

What actually works

Pasting a mega-prompt into chat is theater. Chat is volatile. What sticks is repo-native memory:

.cursor/rules/*.mdc with real globs / alwaysApply and a crisp description
An AGENTS.md the agent is told to re-read after compaction
Small Skills (stepplaybooks) for recurring jobs: add a page, add an endpoint, review a PR

The highest-leverage rule I've found isn't "write clean code." It's an explicit anti-scope-creep + session handoff rule: plan in three bullets, persist decisions on disk, re-read after compression, and don't implement the drive-by idea.

alwaysApply vs globs (the question people actually ask)

Someone replied to my cold-start post: do you scope rules per directory with globs, or keep everything always-on and tiny?

Both, on purpose.

alwaysApply stays tiny: anti-amnesia, anti-scope-creep, security baseline. That layer has to survive context compression every turn.
globs hang stack rules (React forms, Spring controllers, zod ↔ Bean Validation) so they fire only in matching files and don't burn tokens on every open.

If you make fifty rules always-on, you pay context rent and the model still ignores half of them. The free Starter is the tiny always-on core; the paid pack adds the globbed React/Java layer.

React + Java in one pack

Most Gumroad rule packs are Next-only English soup. Dual-stack teams (React/TS front, Spring back) keep re-teaching both sides. Mapping zod ↔ Bean Validation in one rule file sounds boring — until the agent stops mixing DTOs and entities.

Try before you buy

There's a free Starter: three rules (anti-amnesia, security baseline, docs handoff) + a PR-review Skill. The full Agent Memory Pack Bundle (19 rules + 6 Skills, React/Java, EN/ZH) is $29 one-time.

What this is not

Not a promise of bug-free AI. Not a 200-prompt PDF. It's an installable engineering memory layer.

Distribution note (honest)

Public experiments in this niche keep showing the same funnel: longform proof on Dev.to → public repo → checkout. X soft posts help refine the angle; they rarely close the sale alone. So this article is the top of that funnel — not a tweet thread with a buy link.

CTA

Landing + free Starter: https://kangtai-cn.github.io/agent-memory-pack/?ref=devto-amnesia

GitHub (Starter source): https://github.com/kangtai-cn/agent-memory-pack

Buy Full Bundle ($29): https://pancake.waffo.ai/store/facai-p8dgqpdw/product/PROD_3jvtO8nHvcOv2YPQSyOpzf?type=onetime&currency=USD&ref=devto-amnesia

Install the Starter. Force one "after compaction" recovery using AGENTS.md. If that alone saves you a session per week, the Bundle pays for itself.

No fabricated sales numbers. Free dumps are great for breadth; this pack is for repo-native memory.

DEV Community: KANG TAI