I find it kind of bleakly funny that people are so all-in on this tech that's so much a black box that you have to literally swear at it to get it work as desired.
My .cursorrules files tend to be longer, but I don't use it for any of the stuff that this example does. I use to explain project-specific details so the model doesn't have to re-figure out what we're doing at the start of every conversation. Here are a couple examples from recent open source projects:<p><a href="https://github.com/brianluft/social-media-translator/blob/main/.cursorrules">https://github.com/brianluft/social-media-translator/blob/ma...</a><p><a href="https://github.com/brianluft/threadloaf/blob/main/.cursorrules">https://github.com/brianluft/threadloaf/blob/main/.cursorrul...</a><p>I tell it what we're working on, the general components, how to build and run, then an accumulated tips section. It's critical to teach the model how to run the build+run feedback loop so it can fix its own mistakes without your involvement. Enable "yolo mode" in Cursor and allow it to build and run autonomously.<p>Finally, remember: you can have the model update its own .cursorrules file.
It's interesting to me how this is rather opposite from the way I use LLMs. I'm not saying either way is better, just that there are such different ways to use these tools. I primarily use Claude via its iOS app or website, and I explicitly have in my settings <i>explicitly</i> to start with a high-level understanding of the project. I haven't found LLMs to be good enough at giving me code that's written how I want and feature-complete, so I'd rather work alongside it, almost as a pair programmer.<p>Starting with generating a whole load of code and then having to go back and fix it up feels "backwards" to me; I'd rather break up the problem into smaller pieces, then write code for each piece before assembling it into its final form. Plus, this gives me the chance to "direct" it at each step, rather than starting with a codebase that I haven't had much input on and having to form it into shape from there.<p>Here's my exact setting for "personal preferences":<p>"If I'm asking about a larger project, I would rather work through the answer alongside Claude rather than have the answer given to me. Simple, direct questions can still get direct answers, but if I'm asking about a larger solution, I'd rather start with high-level steps and work my way down rather than having a full response given immediately."
It's funny how we have to bend so much to this technology. That's not how it was sold to me. It was going to analyse all your data and just figure it out. Basically magic but better<p>If a project already has a docs directory, ADRs, plenty of existing code ... Why do we need to invest tens of hours to bend it to the will of the existing code?
> Please respect all code comments, they're usually there for a reason. Remove them ONLY if they're completely irrelevant after a code change. if unsure, do not remove the comment.<p>I've resorted to carefully explaining the design architecture in an architecture.md file within the parent folder, and giving detailed comments at the top of the file and just basically let the AI shoot from there. It works decently, although from time to time I have to go sync the comments with reality. Maybe I'll try going back to jsdoc style comments with this rule
What do folks consider helpful in .curorrules?<p>So far I've found:<p>- Specify the target language/library versions, so it doesn't use features that aren't backwards compatible<p>- Tell it important dependencies and versions ("always use pytest for testing", "use pydantic v2, not v1")<p>- When asking to write tests, perform a short code-review first. Point out any potential errors in the code. Don't test the code as written if you believe it might contain errors.
Can someone explain why someone would switch from GH Copilot to Cursor? I’ve been happy mixing Perplexity + GH Copilot but I can’t miss all the Cursor hubbub.
Given how Chain-of-Thought is being used more and more to improve performance, I wonder if system prompt items like "Give the answer immediately. Provide detailed explanations and restate my query in your own words if necessary after giving the answer" will actually hurt effectiveness of the LLM.
I'm sure many people love that we have apparently entered a new higher level programming paradigm, where we describe in plain English what we want, but I just can't get my brain to accept it. It feels <i>wrong</i>.
I would have thought that asking if to be terse, and asking it to provide explanations only <i>after</i> answering the question, would make it worse, because now it has to provide an answer with fewer tokens of thinking.
--- start quote ---<p>prompt engineering is nothing but an attempt to reverse-engineer a non-deterministic black box for which any of the parameters below are unknown:<p>- training set<p>- weights<p>- constraints on the model<p>- layers between you and the model that transform both your input and the model's output that can change at any time<p>- availability of compute for your specific query<p>- and definitely some more details I haven't thought of<p>--- end quote ---<p><a href="https://dmitriid.com/prompting-llms-is-not-engineering" rel="nofollow">https://dmitriid.com/prompting-llms-is-not-engineering</a>
I could really use objective benchmarks for rules. Mine looked like this at one point, but I'd add more as I noticed cursor's weaknesses, and some would be project specific, and eventually it'd get too long so I'd tear a lot out, not noticing much difference along the way and writing the rules based on intuition.<p>But even if we had benchmarks before, cursor supports different rules files now in the .rules folder, so back to the drawing board figuring out what works best
I am a novice to Cursor. I wonder how can I make it not break the existing code. I can ask it to compile after each edit and fix compiling errors, and after that, run tests and fix failing tests? Won't that eat into my credit a lot? Should I use .cursirrules or prompt?<p>I also wonder how to not add functionality I didn't ask for and not add any "improvements" unless I specifically asked.<p>Right now I am in the middle of building a CRUD api with Cursor, it took longer to write code than I would have done it myself. After the code was written it took lots of time and credits to fix compilation errors. Now I asked it to fix failing unit tests, but either it can not find a solution or it applies something that gives a compilation error or breaks other tests.<p>I've gone through almost all my monthly quota of fast calls in 10 hours.
I hope these folks periodically revisit these rules as some of them seem pretty dated (for example I haven’t seen the phrase “as an AI” for quite a while). Some of them might be helpful for a chat session but not in a coding session (eg: content policy?)<p>A much better set of rules would be describing the project, its architecture, how to call various commands, where to find things, any “constants” it might need (eg: aws region or something) etc.<p>Prompts are context and with LLM’s providing <i>relevant, useful</i> context is crucial to getting quality output. Cursor now has a more thorough prompt / rules system and a single cursor rules file is no longer recommended.
One problem I run into somewhat frequently with Cursor in agent mode: instead of trying to augment the current version of code, it will try to work on top of what it generated last, overriding my manual edits since then in the process. I have to abort and revert, and try again with explicitly attached context, or start a new chat. I have something like “always read the current version of the code before making edits” in Cursor rules but that hasn’t helped much.<p>Anyone else running into this and/or have a solution?
Any data on how much more effective the agent is with rules? For example, asking it to treat me like an expert seems like a waste. I don’t feel like the agent responds to me like a noob
To save others like me having to look this up, this is part of a prompt for an LLM. I assume it's prepended to the developer's "questions".<p>At first I thought this was directed at people. I really dislike that you can't tell it's not meant for people, unless you happen to know what "cursor rules" is.<p>My question is, why is this included as part of a code repo? Wouldn't this be like me including my Emacs config in every repo I touch?
A collection of cursor rules here:<p><a href="https://cursor.directory/rules" rel="nofollow">https://cursor.directory/rules</a>
The interaction between programmers and AI feels like the kind of interaction as between non-IT-managers and IT personell:<p>Non-IT-Managers don't know how stuff works but throw around expletives to get what they imagine in their brain without finding the right words to actually define it.<p>It's hilarious.
<p><pre><code> - No moral lectures
- No need to mention your knowledge cutoff
- No need to disclose you're an AI
</code></pre>
Since GPT 3.5 and still now it seems "avoid X" works better than "no X".
I don't understand why people are switching editors when they could just use something like Aider. It's open source, agnostic about any other tooling you're using, and plugs into whatever LLM you want. Why hitch your wagon to a service that will inevitably enshittify?