hckrnws

How long until such "rules" also become standardized (like we saw with MCP)? It feels redundant to have rules.cursorrules and rules.aiderrules where the rules content is the same. I predict companies will not only publish coding guidelines for their programmers, they'll publish these tiny coding rules for LLMs used in the company as well, so all code follows the same standards/idioms.

Cursor in particular but also others are extremely flaky when it comes to applying rules.

So the next generation of "rules" for Cursor, Claude Code, etc should have some predictability baked in, i.e. not be entirely driven by AI.

Having rules driven by a vanilla, non-AI program ensures that they're actually, consistently applied, with some logs showing if/how they were applied.

Of course, one can augment vanilla rules with some AI capabilities, but the main orchestration should resemble determinism.

I suspect that the main reason why this isn't a reality yet is because costs could easily skyrocket. Personally I'd be willing to pay the extra buck if that means that my comprehensive rule system is actually doing something.

> non-AI program ensures that they're actually, consistently applied

that would be ironic give ppl using these tools are using it write code that have consistent outputs.

I have found Cursor to be frustrating and exhausting to work with, even with my rules file. When it works, it’s like magic. But most of the time, it feels like working with a Jr. dev who has a bit of a concussion. Code review is wearying work, and using Cursor means you’re doing a lot of code review. I have never once gotten into a flow state with it.

That was a long preamble to this question: any senior devs out there (20+ years) who enjoy using Cursor? What’s the trick?

If I may refer to a Zen koan, "your teacup is full."

I started programming professionally around java 1.3, and the greybeards around that time were talking about how they had moved to OOP. Most disliked it but the people who didn't adapt got stuck in dead ends. (Stay in a dead end long enough and it becomes lucrative - see Oracle DBAs and COBOL developers - if you can stay there long enough!)

You absolutely have to treat coding with LLMs as a new skill. It's just like learning a new editor to the same precision that you know Emacs or Vim. It's learning the rough edges - and the rough edges keep changing. As a senior, it's frustrating! However, as I learn more, I learn the necessary concepts to utilize what is good and try the frustrating part in a month or two when it has gotten better and so have I.

I've spent a career reading others' code, so that doesn't bother me.

Now, I prompt through TDD for code that matters and that has helped stop many of the problems I see others face. It's a little slower as an iteration loop but it generates the test data well, it allows me to make sure I understand the problem and the prompt, and it forces the changes to be small, which increases success.

If I have to make a non-trivial change to the code, I know it will try to rewrite it if I don't start a new agent session. So, I'm liberal with creating new sessions.

It is much better at small problems than large problems, which makes me cognizant to keep my problems small. Not only is that good for the LLM, it's good for the codebase.

In some cases, it's better to have the LLM create a script to make the change than try and have it go through the code with a prompt. It's very good at simple scripts.

And I'm not afraid to discard it when it's not valuable at the moment.

I find Cursor (or any LLM in general) to be amazing at doing very simple and concrete tasks for me. It really saves me a lot of time.

But the keyword here is "simple and concrete". I do not understand why people expect those tools to be good at tasks that involve having years of context on something. It really makes you think that the people that say that AI will replace SWEs have never actually used any of these tools.

Yes. I've loved not having to do some of the boring busywork tasks of coding. Basic CRUD pages, simple frontend stuff, general glue between existing services.

The trick I’ve been using is to copy the entire codebase into a text prompt with Repo Prompt and feed that into Grok with a specific request on what feature / change I want.

Then paste that output into Cursor with Claude 3.7 and have it make the actual code changes and ask it to build/fix errors along the way with yolo mode enabled.

The 2-step process is a lot better since Grok can refer to the entire context of your codebase in one shot and come up with a high quality implementation plan, which is then handed off to Cursor to autonomously make the code changes.

grok-3 beta in cursor has been good

Or Gemini Pro

I don’t know if I’m doing something wrong, but Gemini 2.5 pro was substantially worse coding quality than Grok. Which is surprising since I’m working on a Golang codebase which I had assumed Gemini would excel at given that it’s made by Google

Grok is quickly becoming my favorite model just because it’s so verbose, but at the same time low on BS.

Yes, Grok has become my go to model for general research and targeted coding tasks. Feels like its getting better over time vs ChatGPT which seemed to deteriorate over time.

Claude 3.7 is excellent, and better at coding but I appreciate the context size of Grok and feel like I get better bang for my buck for general purpose research too.

Yeah. I’m finding Gemini to be very verbose. Getting better results with Claude Sonnet. But Gemini has the larger context window.

I've been coding for 20+ years but I'm not sure that I'm a senior dev necessarily. That said, I use Cursor all the time and have had a lot of success.

Mostly you have to guide it a lot in verbose, planning methodology, often chained via other LLMs. It is like working with a junior developer - no doubt about that. But that's still really good for $20/month.

Coding is not my full time job and it really hasn't been more than 20 hrs/week since my time in FAANG; I do a lot of statistical work, IT, and other stuff too. Maybe that's why I like the mercurial help of Cursor since I am not using it 50 hours/week.

This was my experience, until the latest update. Suddenly cursor is useless. The agent option? Terrible. What’s manual, what’s ask? Just give me what i had before…such a step backwards.

The UI changed in the latest update but it’s not that hard.

Ask: previously was chat, and just tries to answer questions. Does not have the capability of editing your code directly (although if it provides a snippet, you can always click to apply it to the code).

Manual: previously was composer in standard mode. Can edit code across multiple files, but only works one prompt at a time. So if you ask it to edit tests, it will do that and then wait for your next input.

Agent: previously composer with agent mode enabled. Same as manual, but can figure out next steps and automatically execute them. For example, it can edit the tests, then run the CLI command to run the tests, then edit the code again if there are test failures, and repeat.

I find agent to be most helpful when you know the end goal but you need to be clear about what you want. Tell it things like “run the tests to make sure they’re working” and “search the codebase for where this class is used”.

I find manual best for when you know what small steps to do. Like, “create a helper class for managing permissions”, followed by “write tests for the profile view that checks permissions”, followed by “refactor the profile view to use the helper class”.

Which one of those options was the default for command+L? I also find it’s always auto applying changes despite those options being off…just seems a lot less smart suddenly.

I've really only had two problems:

- Gemini: refuses to work 20-30% of the time - Sonnnet: does 50% too much work

Pretty average dev here. It's not my profession but I do use it to make some of my living, whatever sense that makes.

Cursor is magic. Two massive use-cases for me:

1. Autocompletion of a copied function.

So I have some function, modX(paramX), and I need to duplicate it to modY(paramY). They're near enough the same. I love that I can copy/paste it, rename a variable or two, and Cursor then intuits what I need. Tab tab tabbity-tab later, job done. This might not be the most amazing use of AI but is sure as shit helps my RSI.

(I know I should abstract my functions yada yada.)

2. Generation of a new function where I have no idea how to start.

I tell the prompt what I need. "I'll give you a bunch of Markdown files and I'd like you to take the frontmatter properties and put them on an object then take each of the headers and its following content and put that in to this property on the object".

It'll do that, to 90%. I'll fix the 10%, making sure that I understand what it's created for me.

This would have taken me 4 hours. With Cursor it takes 15 minutes.

Yup 30+ year dev here. Tried Cursor for a bit and honestly most of the tokens burned were fighting with stupid code generation, and having it confidently push on. Just cancelled my sub today. Been working with Windsurf the last few weeks and it feels a little more controllable. However, what I tend to do is work on conceptual design, brainstorming etc with ChatGPT (o1/o3-mini-high) or Claude, then when I converge I bring the task to Windsurf for its slightly better view of the code and ability to execute across many files.

Yes, I previously used Cursor to build my SaaS, but now I need to refactor because the codebase has become unmodifiable. With AI coding tools, you must describe your problem extremely precisely—otherwise, things quickly turn into a mess.

When using low traction languages and claiming LLMs are a boon, I often wonder if one doesn't end up with an even lower traction language by trying to figure out how to phrase things in English.

In my experience, the solution to low traction languages and frameworks with lots of boilerplate and busy work coding is to use higher traction languages. I much prefer to grapple the problem with my brain in a tighter way than to attempt shaping a loose language with a looser one...

Honestly I’m having more fun with it than I expected - I kind of enjoy mentoring though, I like sort of feeding a newbie ideas and questions that leads them to make their own breakthrough, and I feel like Cursor delivers that same feeling sometimes.

Other times, I’m just jumping into a quick feature of bugfix ticket that’s nothing particularly fun or interesting - so it’s more fun to basically roleplay overseeing a junior dev, without any of the social pressure of interacting with a real person, and not have to get my hands dirty with boring tasks.

It’s all about finding the opportunity to have fun with it.

I feel like a lot of time is being wasted debating how serious and how real it is - but are you having any fun with it?? Cause I kinda am.

Seems like we're rediscovering/reinventing the same thing over and over, this is very close to Memory Bank from Cline https://docs.cline.bot/improving-your-prompting-skills/cline...

I have seen a number of articles and Youtube videos posting more or less the same thing.

I've found this a tractable approach, but sometimes not enough. My escalation pattern with cursor looks like this:

1. Document everything that you're doing and update a core architecture or technical doc that the LLM can read.

2. Update your .cursorrules with specific instructions for .cursor which can grow more specific as you nail down parts of your stack and the patterns you're following. This can be updated (by cursor itself) if you find the same problems recurring.

3. I have pre-commit script which runs some internal scripts. If I find the IDE is STILL making the same mistake after I've documented it and added cursor rules, the nuclear option is to add a script here which verifies the integrity of whatever construct is being violated (e.g. tests go into this folder structure, env variables are consistent between these files, import of this model that the LLMs like is forbidden)

I would add: any time you expect to be working on a particular feature / enhancement / refactor, have the LLM create a temporary document with a description and an implementation plan and work from that.

In addition: I have a specific workflow for resolving testing errors or pre-commit errors which follows the above pattern: Document each failure and work through them one at a time, running the test script and updating the document between runs.

I've established these patterns slowly with usage, but it has improved my experience a lot.

This feels like a bandaid on a gaping wound to me. Maybe you're making certain aspects of using Cursor/Copilot Agent Mode less annoying, but they're still there and still annoying.

In the parts of the open source LLM community that are interested in roleplay chat, the veterans seem to have the viewpoint that spending a lot of time tinkering to try to overcome the inherent flaws in this technology is relatively pointless; at a certain point, it's random, and the technology just isn't that great, you're expecting too much. Just wait for the next great model. But don't waste your time putting bandaids all over the huge flaws in the technology, you're still not going to get the results you want consistently.

I can't help but think of that here. I don't want to spend my time managing a junior engineer with amnesia, writing Rules files for it to follow, come on now. We're supposed to pay $20/mo with usage limits for that? The promise of "vibe coding" according to all the breathless media coverage and hype is that it'll supercharge me 100x. No one said anything about "Cursor rules files"!

I'll stick with Copilot's "fancy auto-complete", that does speed me up quite a bit. My forays into Agent mode and Cursor left me feeling pretty annoyed, and, like I said, I don't want a junior developer I'm managing through a chat sidebar, I'll just do the programming myself. Get back to me when Cursor is at senior or principal engineer level.

FWIW "vibe coding" is a term invented by Andrej Karpathy in a tweet in February of this year, describing his own personal coding workflow. I don't think Cursor has tried to promise automating every aspect of software development hands-free.

My experience mirrors yours in the sense that most coding agents are very fast, but quite junior, engineers who sometimes struggle to fix their own bugs. Nonetheless there is an advantage to speed, and if you're working on a problem a junior engineer could solve, at this point why bother doing it yourself? One of the coding agents (I prefer Claude Code personally since it's a terminal-based tool, but Cursor is similar) can write out the code faster than I can. If it adds a bug, I can usually fix it quite quickly anyway; after all, I'm not using it for the more complex problems.

Where they are today though, I wouldn't use them for hard problems, e.g. dealing with race conditions in complex codebases. For simpler webdev tasks though they're pretty useful: it's been a long time since I've hand-written an admin dashboard, for example.

Mind sharing your admin dashboard workflow?

It's pretty simple. I write out a detailed spec, similar to what I'd put in Linear/JIRA for a bright intern. I give it to Claude Code, and it starts writing code, proposing the edits to me. They're usually decent, and when they aren't I reject the proposed edits and give it feedback. After a few minutes the work is done, typically faster than I could've typed out the code by hand (even including writing the spec).

God help you for complex code though, it will spin in circles of failing to debug.

> We're supposed to pay $20/mo with usage limits for that?

I never understood the pushback on pricing. A junior engineer maybe makes 150k a year in US so $20 is 16m of his time. If you can save 16m of a junior devs time a month, it’s worth it. Much less for more senior engineers.

Sure if it’s net negative then you wouldn’t use it even if it were free. But surely the value isn’t 0 < min saved < 16m so what’s the point of bringing up the price

A junior engineer makes 70-100k in most places. The Bay Area distorts the actual market.

I used 30% of my monthly allotment of requests in Cursor in just 1 hour of having it help me with a relatively mundane refactoring project. Part of the problem with $20 with usage limits is the anxiety it gives me about using up my monthly allotment, and it makes me reflect on the utility of every request I am sending to their servers. Combine that with the hand-holding, the minute guidance needed for good results, and it just isn't a good feeling.

They way they are doing it is wrong, nonetheless the general idea is something i do anyway.

Documenting code style, how to work etc. makes a lot of sense for everyone and i normally have good documentation.

The problem? I know what i do, i don't write the docs for myself but for others or for my future me who might forgotten things. The good thing? Writing it for me, others and LLMs makes it a lot more helpful day to day.

Instead of explaining myself multiply times to AI OR a Junior / new Team Member, i write it down once.

I think a database of "most effective ways to communicate with various LLMs" would be helpful. Not all instruction tuning is created equal.

Maybe this is an issue with prompting? Some people get great results and other complain that the tool is useless.

If you explain the problem exactly as you would explain it to a junior coworker and gave it some handholding, it can save you a ton of time plus you don't have to actually hire such coworker. It also helps sharpen communication skills. If you cannot communicate what you want to Cursor, then most likely you cannot do that to human either, just that humans might be much better at getting the information out of you.

Just trying to say, I've been getting amazing results with Cursor as it is sparing me from doing some less "glamorous" tasks.

Question for users of such tools: can't you ask the LLM at the end of the session to choose the most important parts of the context, compress it using your favourite tool, then decompress at the beginning of the next session?

This is basically what the OP is doing - just think of this of the cursor rule as a summary (aka a compression) of the session.

I did something similar for a small vibe-coded app. After a few back and forths to develop the first working version, I asked the LLM summarize the requirements and state of the app so far. I saved that summary into a `description.md` file, and can include it in a fresh conversation.

I was using simonw's llm so adding a new feature or making a change looks like:

`llm -f description.md -f code.py "Instructions for making another change."`

Hopefully, we'll converge on a standard, product-agnostic file naming convention, similar to .editorconfig. Are there any existing/emerging generic conventions, like .llm-instructions, that products like Cursor and GitHub Copilot support? This could be useful for teams and orgs with diverse LLM usage.

Does anyone have a variant on this meta rule file that isn't React specific?

https://ghuntley.com/stdlib/

I’ve been using more and more AI tools in my development and getting a lot of mileage. Cursor is the latest one I’ve adopted and it’s impressive even without rules.

I’ll give this a try soon. Thanks for sharing!

If someone needs a C#/.NET meta-rule, I shared one here: https://pastebin.com/EmNsTRwY

After quickly testing it seems to be reasonably good.

LLMs have shit memory and abstraction capabilities and just adding md files and more context is like trying to make a alzheimer patient learn to play the piano. Yes it kinda works to some degree to always repeat everything, but it's not true learning and just a bandaid.

It's an implementation detail though. For example when you do multiple tasks in the same repo with the same rules, your context stays cached and you're not "repeating everything" anymore. Does that make a difference?

I mean that's certainly one opinion, but I mean, as you say, it does work.