Cursor AI Prompts & Rules That Actually Work
21 prompts and rules-file examples to get more out of Cursor's Agent, inline edit, and file mentions. Set up project rules, build features across files, refactor safely, debug with context, and write tests.
In short: This page contains 21 copy-paste ready prompts, organized into 5 categories with a description and pro tip for each. The first 5 prompts are free instantly, no signup needed. Hand-curated and tested by the AI Academy team.
Cursor Rules & Project Setup
4 promptsWrite a Project Rules File
1/21✨ What it does
Generates a tailored rules file from your actual code so the Agent follows your conventions automatically.
Read the codebase and draft a project rules file for Cursor. Include: the tech stack and framework versions, the folder structure and where new files go, our naming and import conventions, the libraries to prefer (and any to avoid), and how we handle errors and tests. Output it as concise, imperative bullet rules I can paste into a .cursor/rules file.
Pro tip: Keep rules short and imperative ('Use named exports', not paragraphs). Cursor follows terse, scannable rules far more consistently than prose.
Add Scoped Rules for a Directory
2/21✨ What it does
Sets up path-specific rules so different parts of the codebase get the right guidance.
Create a scoped rule that applies only to files under [path, e.g. src/api/**]. The rule should enforce: [specific conventions for that area, e.g. all handlers return a typed Result, validate input with zod, never log secrets]. Keep it under 15 bullet points and explain when each rule should trigger.
Pro tip: Use glob-scoped rules for areas with unique conventions (API, UI, tests) instead of one giant global file the model half-ignores.
Document the Codebase for Context
3/21✨ What it does
Creates a high-signal overview that gives the Agent durable context about how the project fits together.
Generate an architecture overview I can keep as a rule for context: the main modules and what each does, how data flows through the app, the key entry points, and the external services we call. Use @[folder] to ground it in the real code and keep it to one page.
Pro tip: Mention the @-folder explicitly so Cursor reads real files rather than guessing the architecture from filenames.
Pin Library Docs as Context
4/21✨ What it does
Pulls official documentation into context so the Agent uses current APIs, not outdated training-data patterns.
I'm using [library/framework] version [X]. Using @Docs for it, summarize the current recommended patterns for [task, e.g. data fetching] and note anything that changed from older versions. Then propose how we should standardize our usage and add it to our rules.
Pro tip: Reference @Docs for fast-moving libraries, it stops Cursor from suggesting deprecated APIs it learned from older code.
Prompts get you started. Tutorials level you up.
A growing library of 300+ hands-on AI tutorials. New tutorials added every week.
Building Features with Agent
5 promptsBuild a Feature Across Files
5/21✨ What it does
Drives the Agent to plan a multi-file change before writing code, so you can correct the approach early.
Implement [feature] end to end. First read @[relevant files/folders] to match existing patterns, then make a short plan listing the files you'll create or change and why. After I confirm, implement it, keeping each file consistent with our conventions. Don't add new dependencies without flagging them.
Pro tip: Always ask for the file-by-file plan first, reviewing the plan is much cheaper than reviewing a 10-file diff after the fact.
Implement Against a Spec
6/21✨ What it does
Ties the implementation to an explicit spec and traces each requirement to real code.
Here is the spec for [feature]: [paste requirements]. Implement it using the existing components in @[folder]. For each requirement, point to the exact code that satisfies it. If any requirement is ambiguous, ask me before coding rather than guessing.
Pro tip: Telling the Agent to ask when ambiguous prevents it from inventing behavior to fill gaps in your spec.
Wire Up an API Endpoint
7/21✨ What it does
Adds a new endpoint that mirrors an existing one so it fits the codebase's established conventions.
Add a [METHOD] [route] endpoint that [does what]. Follow the pattern in @[existing handler file]: same validation, error handling, and response shape. Add the route, the handler, input validation, and any types. List the files you changed and show how to call the endpoint.
Pro tip: Point the Agent at a concrete existing handler as the template, it copies a real example far more reliably than a described pattern.
Build a UI Component
8/21✨ What it does
Produces a new component consistent with your design system and covering real-world states.
Create a [component name] component that [behavior and props]. Match the styling and structure of @[similar existing component], reuse our shared UI primitives, and handle loading, empty, and error states. Keep it accessible (labels, keyboard nav) and add the prop types.
Pro tip: Listing loading/empty/error in the prompt gets them all built in one pass instead of follow-up fixes later.
Integrate a Third-Party Library
9/21✨ What it does
Brings in an external library using its current documented setup rather than outdated patterns.
Add [library] to handle [task]. First check @package.json for the current version (or tell me what to install), then reference @Docs for the correct setup. Wire it into @[target file] following the library's recommended pattern, and explain any config or env vars I need to add.
Pro tip: Have Cursor confirm the installed version before generating integration code so it targets the right API surface.
Refactoring & Cleanup
4 promptsRefactor Without Changing Behavior
10/21✨ What it does
Cleans up code while explicitly preserving behavior and surfacing anything risky.
Refactor @[file or function] to improve readability and remove duplication. Do NOT change its external behavior or public interface. Explain each change briefly, keep the existing tests passing, and if a change is risky, flag it instead of applying it.
Pro tip: Stating 'do not change behavior' and 'keep tests passing' keeps refactors safe, the Agent otherwise tends to 'improve' logic you didn't ask it to touch.
Extract and Consolidate Duplication
11/21✨ What it does
Finds and consolidates repeated logic across the project with a review step before changes land.
Search the codebase for code duplicated across @[folder]. List the duplicated patterns you find, then propose where to extract shared helpers. After I approve, do the extraction and update all call sites. Show the diff for each call site you changed.
Pro tip: Ask for the list of duplications first, you may only want to consolidate some of them, not blindly DRY everything.
Modernize Legacy Code
12/21✨ What it does
Brings an old file up to current standards using authoritative docs rather than guesswork.
Update @[file] to current best practices for [language/framework]: replace deprecated APIs, use modern syntax, and improve typing. Reference @Docs for the correct current patterns. Make changes incrementally and explain why each replacement is the recommended approach now.
Pro tip: Pair this with @Docs so 'modern' means the framework's actual current recommendation, not just the model's default.
Rename and Reorganize Safely
13/21✨ What it does
Performs a project-wide rename while first auditing every place the name is used.
Rename [old name] to [new name] across the codebase and update every import, reference, and string that depends on it. Use @[folder] to find all usages first and list them before changing anything. Verify nothing else breaks after the rename.
Pro tip: Have the Agent enumerate all usages before renaming so you can catch dynamic references that a naive find-and-replace would miss.
Like these prompts? There are full tutorials behind them.
Learn the workflows, not just the prompts. 300+ easy-to-follow tutorials inside AI Academy — and growing every week.
Debugging with Context
4 promptsDebug with Full Context
14/21✨ What it does
Gives the Agent the error, repro steps, and relevant files so it can find the real cause, not a symptom.
I'm getting this error: [paste error and stack trace]. It happens when [steps to reproduce]. Read @[relevant files] to trace the cause, explain the root cause before fixing, then apply the smallest fix that resolves it. Don't refactor unrelated code while you're in there.
Pro tip: Always paste the full stack trace and @-mention the files in it, the line numbers let Cursor jump straight to the culprit.
Add Targeted Logging
15/21✨ What it does
Instruments a tricky code path with focused logging to expose what's actually happening.
I can't reproduce why [behavior] happens. Add temporary, clearly-labeled debug logging around @[function/area] to trace the values of [key variables] and the flow of execution. Tell me what to look for in the output, and remind me to remove the logs after.
Pro tip: Ask for clearly-labeled temporary logs so they're easy to grep and remove once you've found the issue.
Compare Against Working Code
16/21✨ What it does
Uses a known-good implementation as a reference to isolate why a similar one is broken.
The [feature A] works but [feature B] doesn't, even though they're similar. Compare @[file for A] and @[file for B], list the meaningful differences, and tell me which difference most likely explains why B fails. Then propose the fix.
Pro tip: Diffing against working code is often the fastest path to a bug, the Agent spots the one line that diverges.
Trace an Intermittent Issue
17/21✨ What it does
Tackles a flaky, hard-to-reproduce issue by reasoning about non-deterministic causes first.
Sometimes [behavior] fails but usually it works. Read @[relevant files] and reason about what could differ between runs, timing, ordering, state, async race conditions, or external responses. List the most likely causes ranked by probability, and suggest how to confirm each before we change anything.
Pro tip: For intermittent bugs, ask for ranked hypotheses and confirmation steps, jumping straight to a fix usually just hides the real race.
Tests & Documentation
4 promptsWrite Tests for a Function
18/21✨ What it does
Generates meaningful tests aligned with your existing test style and verifies they pass.
Write tests for @[file/function] using [test framework]. Cover the happy path, edge cases, and error conditions, and match the structure of our existing tests in @[test folder]. Run them and fix any failures. List which behaviors are covered and which you intentionally left out.
Pro tip: Ask what was intentionally left uncovered, it reveals assumptions the Agent made and gaps you may want to fill.
Add Tests Before Refactoring
19/21✨ What it does
Locks in current behavior with tests so a later refactor can be verified as behavior-preserving.
Before we refactor @[module], write characterization tests that capture its current behavior exactly as it is today, including any quirks. Don't fix anything yet. These tests should pass on the current code so we can refactor safely afterward.
Pro tip: Characterization tests are your safety net, write them first and a risky refactor becomes a measurable one.
Document Public APIs
20/21✨ What it does
Adds clear documentation to public interfaces without altering behavior.
Add doc comments to the exported functions and types in @[file]. For each, describe what it does, its parameters, return value, and any side effects or gotchas. Match our existing doc style and don't change any logic, only add documentation.
Pro tip: Restrict it to documentation only, otherwise the Agent often 'tidies' code while writing comments and sneaks in behavior changes.
Generate a README Section
21/21✨ What it does
Drafts accurate documentation derived from real files instead of plausible-sounding guesses.
Write a [section, e.g. setup and usage] section for the README based on @[relevant files]. Cover install steps, required env vars, the main commands, and a short usage example, all grounded in the actual code and scripts. Keep it concise and don't invent options that don't exist.
Pro tip: Tell it not to invent options, Cursor will otherwise document flags and config that look reasonable but aren't in your code.
Free tool
Prompt Optimizer
Turn a rough idea into a structured, professional AI prompt.
Frequently Asked Questions
Is Cursor worth paying for?
Read our honest, no-hype breakdown with the real pricing.
Prompts are the starting line. Tutorials are the finish.
A growing library of 300+ hands-on tutorials on ChatGPT, Claude, Midjourney, and 50+ AI tools. New tutorials added every week.
7-day free trial. Cancel anytime.
Related guides