We audited a mature Cursor configuration and found 22 rules with alwaysApply: true, totaling 2,700 lines loaded into every single conversation—including "what's 2+2?" This is the alwaysApply tax.

Configuring Your AI Assistant series

The Discovery

During optimization of a shared Cursor rules repository, we ran a simple audit:

# Count alwaysApply rules
grep -l "alwaysApply: true" rules/*.mdc | wc -l
# Result: 22 rules

# Total lines in those rules
grep -l "alwaysApply: true" rules/*.mdc | xargs wc -l | tail -1
# Result: ~2,700 lines

22 rules × ~120 lines average = 2,700 lines of context loaded in every conversation.

Even when the user asks something completely unrelated, all 2,700 lines are in the context window.

Why This Matters

1. Token Costs

Every token costs money:

  • GPT-4: ~$0.03/1K input tokens
  • Claude: ~$0.015/1K input tokens
  • 2,700 lines ≈ 5,000-8,000 tokens

Per-conversation overhead: $0.08-0.25 (for nothing relevant)

Daily cost (50 conversations): $4-12.50

Monthly cost: $120-375 in wasted tokens

2. Context Window Competition

Models have finite attention:

  • Claude: 200K tokens (but attention degrades with length)
  • GPT-4: 128K tokens

2,700 lines of rules means:

  • Less room for actual code
  • Less room for conversation history
  • Degraded attention on what matters

3. Response Quality

Models perform worse with irrelevant context:

  • More "noise" to filter
  • Higher chance of confusion
  • Slower response times

The Audit Results

What We Found

Category Count Lines Should Be alwaysApply?
core-* (essential) 8 ~600 Yes
core-* (domain-specific) 9 ~1,400 No — use globs
agent-* behaviors 5 ~700 Some yes, some no
Total 22 ~2,700 ~8-10 should stay

Rules That Should Stay alwaysApply

Rule Why
core-ai-assistant Defines AI persona (fundamental)
core-code-quality Universal code standards
core-security Security must never be forgotten
core-workflow Basic development approach
core-error-handling Universal error handling
core-git Commit standards
core-escalation When to ask humans
core-refusal-behavior What to refuse

Rules That Should Use Globs

Rule Current Should Be
core-diagrams alwaysApply globs: ["*.mmd", "**/diagrams/**"]
core-documentation alwaysApply globs: ["**/*.md", "**/docs/**"]
core-logging alwaysApply globs: ["**/log*", "**/logger*"]
core-configuration alwaysApply globs: ["**/*.config.*", "**/config/**"]
core-naming alwaysApply globs: ["**/*.ts", "**/*.py"]
core-data-sourcing alwaysApply Skill (it's a workflow)

Estimated Savings

Before: 22 rules, ~2,700 lines always loaded

After: 8-10 rules, ~800-1,000 lines always loaded

Reduction: ~65% fewer always-on tokens

The Decision Framework

When alwaysApply IS Appropriate

Criterion Example
Truly universal standard "Never commit secrets"
Affects EVERY interaction "You are a helpful assistant"
Safety/security critical "Refuse harmful requests"
Fundamental workflow "Verify before implementing"

When alwaysApply is NOT Appropriate

Criterion Better Alternative
Domain-specific guidance globs targeting relevant files
Workflow/procedure Skill (invoked when needed)
Reference material Skill with references/ folder
Rarely needed Description-based activation

The Test

Ask: "If someone asks 'what's 2+2?', does this rule need to be loaded?"

  • If yes → alwaysApply
  • If no → globs or skill

Case Study: The Logging Rule

Before

---
description: "Logging standards"
alwaysApply: true
---
# 240 lines of logging guidance

Problem: Loaded when user asks about CSS, database, anything.

After

---
description: "Logging standards"
globs:
  - "**/log*"
  - "**/logger*"
  - "**/*logging*"
---
# Same 240 lines, but only when relevant

Result: Only loaded when user opens logging-related files.

The Compound Effect

Individual Rules Seem Small

"It's only 80 lines, no big deal."

But They Compound

Rules Avg Lines Total
5 80 400
10 80 800
15 80 1,200
20 80 1,600
25 80 2,000

Each "small" addition increases baseline cost for all conversations.

The Boiling Frog

You don't notice performance degradation because:

  • It happens gradually
  • You attribute slowness to "the AI being slow"
  • You don't A/B test with fewer rules

How to Audit Your Setup

Step 1: Count alwaysApply rules

grep -l "alwaysApply: true" .cursor/rules/**/*.md | wc -l

Step 2: Measure total lines

grep -l "alwaysApply: true" .cursor/rules/**/*.md | xargs wc -l

Step 3: List them

grep -l "alwaysApply: true" .cursor/rules/**/*.md | \
  xargs -I {} sh -c 'echo "=== {} ===" && head -5 {}'

Step 4: Evaluate each

For each rule, ask:

  1. Does this apply to EVERY conversation?
  2. Could this be glob-triggered instead?
  3. Is this really a skill (workflow)?

Step 5: Migrate

  • Change alwaysApply: true to globs: [...]
  • Extract workflows to skills
  • Delete redundant rules

Organizational Patterns

For Teams

Problem: Everyone adds alwaysApply rules, no one removes them.

Solution:

  • Require justification for alwaysApply
  • Regular audits (quarterly)
  • Budget: "We allow X lines of alwaysApply rules"

For Shared Configurations

Problem: Upstream rules affect all downstream users.

Solution:

  • Minimize alwaysApply in shared configs
  • Let downstream add their own if needed
  • Document what's always-on and why

Common Objections

"But I might need it!"

Response: That's what globs and skills are for. You'll still have the rule when relevant.

"Performance impact is small"

Response:

  • It's not small at scale (50+ conversations/day)
  • It compounds with each rule
  • It degrades response quality

"I can't remember which file triggers which rule"

Response:

  • Document your globs
  • Use clear, specific patterns
  • The AI doesn't need YOU to remember—globs handle it

Benchmarks

Based on our audit:

Metric Healthy Concerning Critical
alwaysApply rules < 10 10-20 > 20
alwaysApply lines < 1,000 1,000-2,000 > 2,000
% of rules as alwaysApply < 30% 30-50% > 50%

If you're in the "critical" zone, your AI is working with one hand tied behind its back.

Key Takeaways

  1. Every alwaysApply rule is a tax. Paid on every conversation, whether relevant or not.

  2. Most rules shouldn't be alwaysApply. If it could use a glob, it should.

  3. Audit regularly. Rules accumulate; performance degrades gradually.

  4. Budget your always-on context. Set a line limit and enforce it.

  5. The 2+2 test. If a rule doesn't need to be there for "what's 2+2?", don't make it alwaysApply.

What's Next

You know the cost of alwaysApply. But what about skills? If they're not alwaysApply, how does the AI find them? The next post covers the discovery mechanics—and why your carefully crafted skills might not be getting used.

Next: How Cursor Finds Skills — Discovery mechanics and the glob trap