How to Write Good Prompts in Cursor

A reliable prompt carries four things: the goal with its constraint, the exact files as context, a request to plan before editing, and a way to check the result. You don't need all four on a one-line fix, but on anything non-trivial the agent does better work when you supply them.

The order in that list is not decorative. Goal and constraint come first because the other three are scoped by them: which files count as context, what the plan is a plan for, and what a passing check would even prove. Verification sits last and it is the one that gets dropped, probably because by the time the first three are written the prompt already looks finished.

The constraint is the half of that first line most people leave off. "Add pagination to the users list" and "add pagination to the users list without changing the public API" produce different diffs, and only the second one is quick to review. Write the constraint even when it feels obvious, since the agent has no way to know which parts of a file are load-bearing for somebody else.

Most of the gain comes from a few habits you repeat. Be specific about files and behavior, keep one task per chat so the context stays clean, show an example of the pattern you want, and push your durable conventions into rules instead of retyping them. When a tangent comes up mid-task, spin it into a side chat instead of derailing the main thread.

• Be specific - name files, functions and the exact behavior you want.
• One task per chat - start fresh per task to keep context clean.
• Show an example of the pattern you want followed.
• Put durable conventions in rules, not in every prompt.

Of those four, one task per chat is the one with a real cost behind it rather than a preference. A long thread compresses its own history every turn, so the context you care about ends up competing with everything the thread has already said. Start a new chat when the task changes rather than when the thread starts to feel long.

Here's the same intent written two ways. The vague version makes the agent guess what you meant and search the repo to orient itself. The scoped version names the file, the change and what not to touch, so the agent starts on the right code.

Fill in the slots and the composer assembles them into a single prompt you copy straight into the Cursor agent. The @-mention stays a live reference, so the agent opens the file you named instead of grepping for it.

That advice has an edge Cursor states plainly and this page has been glossing over. Naming the file is right when you already know which file matters. When you do not, the documented guidance is to skip the mention and let the agent search, because a guessed-at list of five files is noise dressed up as direction. The scoped example above works because whoever wrote it knew the checkout form lived in one component. On a codebase you have not learned yet, describe the behaviour precisely and leave the file list empty.

Go back to the plan instead of sending another prompt. Cursor's recommendation for a result that misses is to revert the changes, make the plan more specific and run it again, which tends to be faster than steering an agent that is already halfway into the wrong approach.

Follow-ups feel cheaper, and that is the trap in them. Each one lands in a thread that already holds the reasoning behind the wrong answer, so you are asking the model to argue with itself while the bad context stays in the window. A revert costs you the diff and leaves the plan, and the plan is where you can change one line and try again.

When a fresh, well-scoped prompt keeps producing the same wrong thing, the cause is probably upstream of the prompt. A convention you find yourself restating every time belongs in a rules file. A thread you have been extending all afternoon is carrying context that no amount of rewording will outrun, so start a new chat for the next task.

Text isn't the only context the agent takes. Some of the strongest prompts hand it a website, an image, or a spoken brain-dump - whatever carries the intent fastest.

• A live site or brand-guidelines URL - Cursor has web access, so "use the HTML and CSS from the Cursor docs page" makes it navigate there, read the visual structure and typography, and apply those tokens to your prototype. A brand-guideline PDF works too: drag it in.
• Images - hand-drawn diagrams, screenshots, sketches. One team uploaded photos of their hand-drawn technical designs and Cursor turned them into Mermaid diagrams they published to FigJam.
• Voice - click the microphone icon and just talk; review the transcription before it sends. It's the lowest-friction way to dump everything in your head into the agent.