How I use Cursor

Background: my mental model for AI and these tools

"Machine learning and statistics are not epistemologies trying to ascertain true theories of reality - they are useful tools to help us find patterns in carefully curated datasets, in order for us to obtain actionable information." (source).
Hence, AI coding tools are helpful when aligned with how they work: productivity, implementation, common tasks, breadth.
- Associations from simulated closed systems often don't hold: likely why METR plots emphasise <80% success rate (source).
Less useful for: novelty, causal explanation, extrapolation beyond training data, understanding.

Modes

Agent — Autonomous: explores codebase, runs commands, makes edits. Ensure sandboxed and safe.
- e.g., "Find any security issues and fix them"
- I use this and autocomplete mostly.
Plan — Creates a plan before execution, reviews with user first, then goes to agent.
- e.g., "Create a new ML weather model for nowcasting precipitation using radar over the US"
Debug — Generates hypotheses, debug server, reproduction steps, find root cause before edit (copy traceback, bugs, performance).
Ask — Chat: answers questions, explains code, no changes made.
Select between modes in chat.
Set a default mode in Cursor settings.

Manage context

This is the "working memory" that gets wiped per chat — think the film Memento.
This is what your paying for (i.e., tokens in/out). Careful if cost is by usage or has overcharges on subscriptions.
More context does not necessarily mean better output if unfocused/diluted, hence why autocomplete can be more accurate. Watch context usage (circle under chat) and be selective. If context is getting full or on a different task, start new chat.
Keep important context in files (e.g., AGENTS.md) not just chat.
Focused @ mentions e.g., @file, @folder, @web, @docs.
Add websites and files (e.g., plots, diagrams, screenshots) to context.

Guidance

User rules: e.g., analyze from multiple perspectives, include uncomfortable truths, verify assumptions, admit uncertainty, explain trade-offs, simple means easier to understand, minimal changes.
Project rules: custom repo rules for common questions, can always apply, or apply via a glob e.g., all files in docs/.
AGENTS.md: small persistent context per repo, common workflows for any agent to give itself feedback.
.cursorignore to exclude restricted/unimportant/large files from indexing (if change then reindex in settings).
Commands: custom commands for common tasks e.g., /help, /new-app, /migrate-ci, /terraform-setup.

Tools

Slack: integrate, settings for model and repo, @Cursor fix the issue in this thread.
Commands: ask every time (safest) or auto-run in sandbox with strict allow list e.g., allow read-only ones, deny git commit/push, rm, kubectl delete, curl/wget, etc.
Browser: disable auto-accept web search, disable auto-run network access, disable git writes without approval, enable protection for browser and file deletion.
MCP: connect to external services e.g., Atlassian (Confluence only), Monday. Use official servers. I have them both to read-only.
- e.g., "Search Confluence for weather ownership doc. What do I own?"
- e.g., "Show Monday tickets assigned to me"

Useful things

Migrate settings/extensions from VSCode: instructions.
Diffs: review on proposed changes.
Autocomplete: start typing some code, then tab.
Review: use @branch in chat to review a branch vs. main.
Diagrams: ask Cursor to create diagrams.
Parallel tasks: start agents on different tasks, each has own context.
Agent review on commit.

Tips

Get in the habit of asking Cursor (e.g., before someone on Slack). Can often diagnose yourself and learn as you do via tailored explanations. It will never get bored and there really is no silly questions. Ask it to explain everything you don't know.
Ensure it does web searches for questions that benefit from recent information (beyond training cutoff date).
Smaller, focused tasks. Autocomplete is a smaller task than agent/plan, hence often higher accuracy to intent.
Create feedback loops for the agents e.g., how it can run tests.
Tweak the autonomy to your preferences e.g., mode, what it can do, etc.
Commit often — easy to revert.
Be clear/precise/explicit with requests.
Iterate on output.
Interrupt if off-track.

Recommendations

Try the experiment for yourself. Compare with and without AI coding tools for criteria you care about.
Be skeptical. Test, verify, validate.
Current favourite models:
- Vary with capabilities (e.g., context size, reasoning), speed, cost, performance at task you require (experiment, benchmark tests), etc.
- Questions - Sonnet 4.5, as searches web more.
- Code - Sonnet 4.5 (thinking) / Opus 4.5 (thinking), as thinking variants use extra tokens to break questions into steps.
- I change between them manually.
- Be ready to change them as improvements come.
- Good recommendations from Andrej Karpathy.
Check out Cursor Docs and Cursor Learn.

Opinions

"Overall, the models are not there. I feel like the industry is making too big of a jump and is trying to pretend like this is amazing, and it's not. It's slop. They're not coming to terms with it, and maybe they're trying to fundraise or something like that. [...] For now, autocomplete is my sweet spot. But sometimes, for some types of code, I will go to an LLM agent." - video

"For some kinds of tasks [...], there's a very large demo-to-product gap where the demo is very easy, but the product is very hard. It's especially the case in cases like self-driving where the cost of failure is too high. [...] For example, in software engineering, I do think that property does exist. For a lot of vibe coding, it doesn't. But if you're writing actual production-grade code, that property should exist, because any kind of mistake leads to a security vulnerability or something like that. [...] So in software, people should be careful, kind of like in self-driving. [...]" - video

— Andrej Karpathy (coined "vibe coding", CNNs, Tesla, OpenAI, Stanford, etc.)

"We need to deliver code that works — and include proof that it works." - article

— Simon Willison

"Our ability to zoom in and implement code is now obsolete. Our ability to zoom out and think well is not. On the contrary, our ability to think well is now 10x more valuable than it was before, because implementation is now mostly free." - article

— Matthew Rocklin (dask)

My results and thoughts

AI coding tools are incredibly valuable. I'm way more productive. I can go into new areas and build stuff quickly. They're amazing for implementation, debugging, exploring, and learning.
Though, that's not the whole story. Programming is theory building (unseen), not just the implementation (seen, the code).
If you didn't implement it, then the theory is harder to obtain. Hence, why other people's code is hard to read, understand, and often you want to start from scratch to develop your own solution.
So as implementation is handed to LLMs, then this challenge is more widespread.
Understanding is now even more important for the problem, domain, system, context, constraints, and trade-offs.
Utlimately, the goal is to solve the problem, not write the code.