Cursor at Scale: Rules, Context Files, and Multi-File Refactors

The difference between developers who get enormous leverage out of an AI editor and developers who find it a novelty is almost never model choice. It is context discipline. On a small project the model can see most of what matters. On a hundred-thousand-line codebase it sees a keyhole, and your job is to point the keyhole at the right place.

Write rules that encode decisions, not style

Project rules files are most valuable when they capture decisions a newcomer could not infer from reading a random file: which data-access layer is canonical, which utility is deprecated but not yet deleted, which directory is generated and must never be hand-edited, how errors are surfaced to users. Formatting conventions are better handled by a formatter than by a paragraph of instructions the model has to spend attention on.

• State the canonical pattern and name the file that exemplifies it.
• List the traps: generated files, legacy directories, modules with subtle invariants.
• Keep rules short. A thousand-line rules file competes with the code for attention.
• Scope rules to directories when your repository has genuinely different conventions in different areas.

Curate context deliberately

Automatic retrieval is good at finding lexically similar code and poor at finding the file that defines the constraint you care about. Before a non-trivial task, attach the specific files: the interface, one existing implementation to imitate, the test file, and the type definitions. Three well-chosen files beat twenty automatically gathered ones, both for quality and for cost.

Stage large refactors

Asking for a sweeping change across forty files in one instruction produces a diff nobody can review and a model that loses coherence halfway through. Stage it instead. First, ask for an inventory: every call site, every affected type, grouped by module. Review that inventory yourself — it is where the model's misunderstandings surface cheaply. Then convert one representative module, verify it, and use that converted module as the reference example for the rest.

Ask for the inventory before the edit. A wrong list costs a minute to fix; a wrong refactor costs an afternoon.

Give the model a feedback signal

The largest quality jump in agentic editing comes from letting the model run something and read the result: a typechecker, a linter, a focused test command. Without that loop it is writing code blind and you become the compiler. With it, most syntactic and type-level mistakes are corrected before you ever see them. Make sure the fast commands really are fast — a two-minute test suite turns the loop into a bottleneck, so keep a targeted subset available.

Know what to keep for yourself

Delegate mechanical transformations, boilerplate, test scaffolding, and code that follows an existing pattern. Keep the parts where the cost of a subtle error is high and the pattern is not yet established: concurrency, security boundaries, data migrations, public API shape. The productive division of labour is that you decide what should exist and the model handles the typing.