Capstone: Build Your Personal Cursor Setup

Your Cursor Setup Checklist

Work through this checklist in order. Each step compounds on the previous one:

1. Install Cursor and import VS Code settings. Go to cursor.com, install, and use the import flow on first launch. Your extensions and keybindings come with you.
2. Start with the Hobby plan. Use it for a week before deciding whether to upgrade. Most developers hit the limit within a few days of real use, which tells you whether Cursor is worth the Pro subscription. Upgrade when you start getting blocked by limits — not before.
3. Enable Tab and leave it on. Don't evaluate Tab on day one — it takes a few days before you start intuitively knowing when to accept or ignore it. Just let it run.
4. Create your first rules file. Even 10 lines is better than nothing. Open .cursor/rules/project.mdc, add your tech stack and the two or three standards you care most about. You will iterate on this over time.
5. Add @docs for your top three libraries. Pick the libraries you write the most code against and add their documentation URLs. The quality improvement on library-specific code is immediate.
6. Connect GitHub MCP. Install it from Settings → MCP. It takes two minutes and makes issue-driven development significantly faster.
7. Install BugBot on your main repository. Set it up once, benefit on every future PR.
8. Set your default model to Auto. Start there. Override to Sonnet or Opus explicitly only when Auto underperforms on a complex task.

The Five Most Common Cursor Mistakes

These are the patterns that consistently produce frustration among new Cursor users. Knowing them in advance lets you skip the frustrating part:

1. Prompting like ChatGPT. Vague requests like "write me a REST API" or "refactor the auth system" produce generic output. Cursor is in your codebase — give it specific context. Better: "Add a POST /users endpoint to routes/users.ts using our existing Drizzle schema in db/schema.ts. Follow the same pattern as the GET /users route above."

2. Skipping Plan Mode. Most developers open Agent, type a task, press Enter, and let it run. For simple tasks this is fine. For anything complex — more than a few files, any architectural impact, any unfamiliar area of the codebase — this produces the wrong output. Shift+Tab takes 30 seconds. The plan it generates saves hours.

3. Blindly accepting diffs. The diff view exists because AI-generated code has errors. Not always — but often enough that reviewing every diff is a professional habit, not optional caution. Read the green lines. Read the red lines. Especially check imports and error handling.

4. Ignoring model selection. Auto mode is good. It is not perfect. When a complex Agent task produces shallow or incorrect output, switch explicitly to Claude Sonnet or Opus for that task. The credit cost is worth it when the output quality difference is significant. You'll learn over time which task types benefit from an explicit upgrade.

5. No rules file. Setting up rules after months of inconsistent output is painful — you have to go back and re-prompt everything you should have gotten right the first time. Set up your rules on day one of a project. A 10-line rules file is 10x better than none at all.

Your Daily Cursor Workflow

A pattern that works well once you have your setup in place:

• Tab runs all day in the background — Accept it when it's right, ignore it when it isn't. It improves passively as you build context in the file.
• Cmd+K for targeted fixes — Refactoring a function, adding type annotations, converting a pattern, explaining and rewriting a dense block. Fast, surgical, single-file.
• Chat + @codebase for understanding — New to a module? Debugging something unfamiliar? Ask Chat with @codebase. It finds the relevant code without you having to know where to look.
• Agent + Plan Mode for multi-file tasks — Anything that touches more than one file. Always Shift+Tab to plan first on anything non-trivial.
• Automations for recurring tasks — PR review, daily summaries, ticket-to-plan. Set them up once, let them run indefinitely.

Compounding Returns

The most important thing to understand about Cursor is that it rewards investment. The more context you give it — through rules, @docs, Memories, MCP connections — the better every future interaction becomes. A Cursor setup you've invested a week in will outperform a fresh install by a wide margin, because the AI is working from a rich and accurate model of your project.

Start small. Get the checklist done. Iterate on your rules as you notice patterns in the output. Add MCP servers as you hit the limits of local-file-only context. The compounding starts on day one.