Why Cursor Keeps Doing Something Else (And How to Fix It)

You give Cursor a simple task. It comes back with something... creative. You try again, more specific this time. It changes files you didn't ask it to touch.

I spent months thinking I was bad at prompting. Turns out, I was using Cursor wrong.

TL;DR Default to Plan Mode for anything beyond a trivial edit, and attach context with @Code instead of @folder, since folders get condensed rather than fully read. Replace vague requests with contracts: goals, non-goals, constraints and acceptance criteria. Then force verification with a Verifier subagent and Agent Review before you trust the result.

The Root Cause: Context

When you reference @folder or @codebase, Cursor gets a condensed overview, not the full contents. Large files get truncated.

"Large files and folders are automatically condensed to fit within context limits" (Cursor docs)

If you see "condensed to fit context limit," expect degraded results.

Anthropic calls this context engineering: managing what state the model actually has.

Approach	Risk Level
`@Code` (specific functions)	Low
2-5 explicit files	Low
`@folder`	Medium
`@codebase`	High

Don't assume Cursor "will find it." Attach files explicitly.

Contracts, Not Commands

Most drift happens because "do X" still leaves 50 degrees of freedom.

Stop saying "do X." Define a contract.

Vague	Contract
`Add feature flag support to the API`	Goal: add feature flag check to /api/users. Non-goals: no refactoring, no new deps. Constraints: follow pattern in products.ts. Acceptance: npm test passes.

This is the single biggest "Cursor starts obeying me" lever.

The Orchestrator Pattern

Cursor 2.4 introduced Subagents: specialized agents with their own context. Use them as a team:

flowchart TB
    You["YOU: Define scope, constraints, acceptance"]
    Planner["PLANNER: Plan Mode"]
    Review["Review & approve"]
    Implementer["IMPLEMENTER: Executes plan"]
    Verifier["VERIFIER: Tests, confirms requirements"]

    You --> Planner
    Planner --> Review --> Implementer
    Implementer --> Verifier

Key insight: "It does something else" = Implementer without a Verifier gate.

When you skip verification, you're trusting the model to self-police. It won't.

Plan Mode + Agent Review

Plan Mode: Start here for any multi-file task. Cursor asks clarifying questions, researches your codebase, then produces a reviewable plan before touching code.

Agent Review: Review proposed diffs file-by-file before accepting. If the task touches >2 files, always review.

Verify Your Rules Work

Cursor forum users report rules don't always apply. Add a sentinel check to your always.mdc:

# Verify rules are active (remove after confirming)

Start responses with: RULES_ACTIVE

If you don't see RULES_ACTIVE, your rules aren't being applied.

File Structure (Cursor 2.4)

your-project/
├── AGENTS.md                    # High-level instructions (keep thin)
└── .cursor/
    ├── rules/                   # Declarative, always-on
    │   └── always.mdc           # Style + safety boundaries
    ├── skills/                  # Procedural workflows
    │   └── work-order/
    │       └── SKILL.md
    └── agents/                  # Custom subagents
        └── verifier.md

The Bottom Line

Cursor is powerful, but not magic. It's a model working with whatever context you give it.

Three things that matter:

Plan Mode: for anything beyond a tiny edit
Precise context: @Code and explicit files
Verification: require evidence, not trust

The goal isn't to make Cursor perfect. It's to make its mistakes cheap to catch.