How to give Cursor feedback on a long Markdown file (without it rewriting half the README)

By Elad Diamant·Published April 24, 2026

You opened README.md in Cursor. You asked it to tighten the "Overview" section. Cursor opened a diff. The diff was the first 240 lines of the file. The Overview is now four sentences shorter, the Installation block has a new paragraph about "developer ergonomics," and the example command has a trailing flag you have never used. You hit ⌘Z. You sigh. You think, briefly, about going back to vim.

This is not Cursor being clumsy. It's Cursor being right about code and wrong about prose.

Why Cursor's instincts work for code and break on prose

When you ask Cursor to "refactor the auth handler to use the new session interface," the model has unambiguous targets. There is exactly one auth handler in auth.ts. The function signature is precise. The new session interface is in types/session.ts. Cursor reads the right files, applies a focused diff, and you click Accept. The whole experience is the reason you bought Cursor.

Now: ask the same model to "tighten the Overview section of the README."

The Overview is six paragraphs. The word "overview" appears three times in the file (the section heading, a sentence in the Installation block, a comment in a fenced code example). The "tightening" instruction has no obvious stopping condition. Cursor's behavior under ambiguity is to broaden — read more of the file to ground the edit, apply changes that maintain stylistic consistency across the broadened context, present the whole thing as a diff. That broadening is the right move on code (where consistency matters across files) and the wrong move on prose (where you wanted six sentences to become four).

This is the same target-selection problem you hit with Claude and ChatGPT in the chat box, just with a different surface area. Same root cause, slightly different symptom. We wrote up the chat-box version of this problem here; the rest of this piece is the Cursor-specific playbook.

Composer vs Agent vs Chat — which to use for prose

(Cursor's mode names and defaults shift. The breakdown below reflects Cursor as of April 2026 — Agent as the default autonomous mode, Composer as the focused single-file edit surface, Chat as the conversational sidebar. Cursor's own docs are the source of truth if names have moved by the time you're reading this. The principle — code-tuned tools broaden on prose — holds across every renaming.)

The chat-mode workflow that works

1. Open the file in the editor and select a passage — Cursor's Add to chat action makes the selection the active context for chat. Or skip the selection step and paste passages manually; either works.
2. Compose the paired-passage block in chat. Each block is a verbatim quote of a passage from the file, followed by your note, separated by ---. Prefix the whole thing with "Apply these edits to README.md. Leave everything else unchanged. Return a diff."
3. Send. Cursor returns a diff containing only the edits at your quoted passages.
4. Accept the diff. Done.

Concretely:

Apply these edits to README.md. Leave everything else unchanged. Return a diff.
---

"OMGfixMD is a comprehensive solution that empowers users to leverage..."
[Off tone] Rewrite as: "OMGfixMD is a browser tool for leaving inline comments on Markdown."

---

"## Overview

OMGfixMD seamlessly bridges the gap between..."
[Delete entire paragraph] Replace with one sentence: "It's the comment box your LLM doesn't have."

---

"### Installation

Run `npm install -g omgfixmd-cli` to..."
[Factually wrong] We do not have a CLI. Delete this section entirely.

---

Three passages. One message. Cursor reads each quoted block, locates it in the file by exact-text match, applies the note in place, and produces a diff that touches only those regions. The Overview section's other paragraphs do not change. The Installation block's other items do not change. You did not have to undo three edits before keeping the one you wanted.

What the diff actually looks like, side by side

Concrete, because the abstract version is unconvincing. Same README, same three edits, same model. First, the prose-prompt version of the request:

Tighten the Overview section, fix the Installation block,
and remove the corporate phrasing from the intro.

Cursor opens a diff. The diff is 247 lines across the file: Overview rewritten in a different voice, Installation reformatted with a new sub-heading, intro replaced with a paragraph using "developer-friendly" twice, plus four "stylistic consistency" tweaks in sections you did not name.

Now the same three edits in paired-passage form. Cursor opens a diff. The diff is 11 lines: three deletions, three insertions, no surprises. You hit Accept. You ship. The rest of the README is byte-identical to the source — line counts, anchor links, even the trailing newline.

247 lines of "let me think about that for you" versus 11 lines of "here is what you asked for." Same model, same tool, same minute. The only difference is whether the input named the targets.

Use .cursorrules to make this the default

If you're going to do this more than twice, push the discipline down to project level. Cursor reads a .cursorrules file (or a .cursor/rules/ directory in newer versions — check Cursor's docs for the current spec) at the repo root and treats it as a system-prompt prefix for every chat in that project. Drop a rule like this in:

# .cursorrules

When the user provides feedback as paired blocks of "quoted passage" + note,
separated by ---, treat each block as an atomic edit on Markdown files:

- Locate the quoted passage by exact string match.
- Apply the note's instruction to that passage only.
- Leave every byte outside quoted passages unchanged.
- Return a diff, not the full file.
- If a quoted passage cannot be matched verbatim, skip it and report
  the failure at the end. Do not approximate.

This rule applies to .md, .mdx, and .txt files. It does not apply to
source code edits, where broader refactoring is often what the user wants.

Now every edit pass on Markdown in this repo respects the paired-passage discipline without you re-typing the prefix every message. The same recipe with slightly different framing exists for system prompts and Claude Project instructions — full version in the prompt playbook.

Same problem in Windsurf and Zed AI

The behavior generalizes. Windsurf's Cascade and Zed's AI assistant both inherit the code-tuned defaults that make Cursor over-broaden on prose. The paired-passage workflow ports cleanly: open the chat sidebar, paste the prefix-plus-blocks, accept the diff. Windsurf has its own analog of .cursorrules (.windsurfrules) and Zed exposes assistant settings in the project config — both work as the system-prompt anchor for the same rule above. If your team mixes editors, write the rule once and translate the filename per tool; the body stays identical.

Why the verbatim quote is doing all the work

This is the same mechanism we walk through in the guide: a verbatim quote is a coordinate the model can match by exact text rather than infer from prose description. In Cursor's chat mode, that coordinate also tells the underlying tool calls (read_file, apply_edit) where the edit should go — which means Cursor's broadening behavior gets gated by the bytes you quoted, not the topic you described.

Without the quote, you are asking Cursor to find the passage. With the quote, you are telling Cursor where the passage is. The difference between those two verbs is the difference between a diff that touches three lines and a diff that touches three hundred.

Per-mode rules of thumb

If you must use Agent for a Markdown file

Agent will go off script. Constrain it: "Edit only the lines containing the following quoted text. Do not modify any other lines. If a quoted passage cannot be found verbatim, skip it and report the failure — do not approximate." Agent respects these constraints more than you'd think, but check the diff scope before accepting.

If you're in Composer

Composer is fine for one passage. Past two, switch to chat. Composer's bias toward "complete" edits gets stronger when you stack multiple instructions in one message.

If the file is over 5,000 words

Don't paste the file into chat. Use Add to chat on the specific selections you're editing. Cursor handles long files via its own retrieval; you do not need to fight it for context.

If you need to also restructure

Split into two passes. First pass: paired-passage edits (phrasing, deletions, factual fixes). Second pass: structural moves ("move section X below section Y"). Mixing the two in one message is where Cursor's broadening creeps back in.

The cruel twist

Cursor will almost certainly ship a "comment on this passage" surface in the editor itself within the year — probably as part of a broader push toward prose editing as a first-class workflow. The paired-passage workaround in this post will then look like the historical curiosity it deserves to be.

Until then, chat mode plus paired passages is what works. If you'd rather highlight passages in a browser and have the block built for you, OMGfixMD exists for exactly that — paste the file, highlight every passage, attach a note per highlight, copy the block, paste into Cursor's chat. ⌘⇧C, ⌘V, done.

OMG.