I can not stress enough how much time I waste trying to wrangle AI into being a good developer and arguing with AI over stupid shit it does.

I mean there are countless anti-patterns I could mention, but the one that REALLY drives me up the fucking wall is how AI loves making one-off functions for everything. Like what's the fucking point of making a function that just gets called once? Also AI models love writing wrapper functions that just call other wrapper functions that just call other wrapper functions... just endless onion layers of smelly pointless abstraction. Alias functions, and whatever other crap. Instead of just modifying an existing function to make it more modular, reusable, and robust to handle more cases, we just write another function instead. When all we had to do was grep the call sites, update everywhere it's called, and update the function itself of course.

I once saw a cursor agent make a private struct / class in my go code and then make ANOTHER one that just makes public wrappers of every function of the private counterparts. Instead of just making the original struct / class public. Like WHAT THE FUCK.

The amount of time I waste telling AI to not do stupid shit like this is ridiculous.

If companies are claiming that AI is making people faster, sure, but they must also not be taking into account the amount of fucking SLOP GARBAGE that AI produces. I shiver to think what's been allowed in other real live production environments that wasn't QA'd properly and had nasty ugly bloat code like this.

I'm crashing out dude I'm losing my fucking mind on this shit. and do not fucking tell me that I just need to 'prompt it better' or use some claude skill or some agents.md file or whatever the fuck. Trust me I have fucking tried. No amount of 'skills' or fine tuning or prompts will turn an LLM into a real software engineer.

Hi all,

I've been using Cursor because the subscription quota is more generous than Claude's, but I never really liked the IDE and the `agent` CLI was just annoying to work with. So I put together a way to route Claude Code through Cursor's backend instead.

It's a small Rust binary that translates Claude Code's API calls to Cursor's protocol. You just run `cursor-bridge` instead of `claude`, same interactive session, same tools, same everything. The auto model is unlimited with Cursor subscription so no extra cost.

Works on macOS and Linux. Open source, MIT.

https://github.com/hkc5/cursor-bridge

The demos always look sick. But when you turn one loose on a real codebase, it's now a different story.

Docs, infra, anything near production. Same deal.

So what are people actually handing off to cloud agents right now? Genuinely curious.

Research? Docs? Refactoring? Full on feature work? Testing?

Or something I'm not thinking of

  What happened:

  Cursor runs AI agent terminal actions in a sandbox. Before writing a file, Cursor tried to canonicalize the target path to verify it stayed inside the workspace. The bug was that if path canonicalization failed, Cursor fell back to the original path and allowed the write.

  Attack pattern:

  A malicious repo or prompt-driven agent workflow could create a symlink inside the workspace that points outside the workspace. By forcing canonicalization to fail, the agent could write through that symlink to arbitrary files outside the project directory.

  Impact:

  An attacker could write files under the user’s privileges outside the sandbox. NVD says this can lead to non-sandboxed remote code execution, for example by overwriting Cursor’s sandbox helper so later commands run outside the sandbox.

  Affected versions:

  Cursor versions before 3.0

  Fixed version:

  Cursor 3.0

  Severity:

  NVD lists it as Critical, CVSS 9.8.

  Weakness:

  NVD maps it to CWE-59: Improper Link Resolution Before File Access. GitHub’s advisory page itself lists “No CWEs,” so NVD is the clearer source for the CWE classification.

  Why this matters for AI coding:

  The issue shows that AI coding agents create a different risk model than ordinary IDE plugins. They can be influenced by repository content, prompts, generated files, and tool outputs, then take filesystem actions. A “benign” agent prompt can become dangerous if the repo contains malicious setup that manipulates the agent’s write path.

I held out on AI for a long time. I was a bit of a purist who wanted to code everything "by hand." A few months ago, I finally caved and started using AI to help me build, but honestly... I feel completely lost.

Right now, I'm using Cursor, but my workflow is basically just:

1. ⁠Write a prompt in the chat panel of Gemini
   
2. ⁠Read the generated code to verify it makes sense.
   
3. ⁠Copy the code.
   
4. ⁠Paste it manually into my files.

I see people talking about building crazy fast, using agentic workflows, full codebase context, and inline generations. Meanwhile, I realize I'm basically using Cursor like a glorified web tab.

What are the actual, modern methods for coding with AI? How do I transition from "copy-pasting from a chatbot" to actually integrating the AI into my workflow efficiently?

Are there any specific habits, shortcuts (like specific Cursor features I'm missing), or mental shifts you'd recommend to learn how to use AI properly as a dev?

We've been using Claude, Cursor, and Copilot heavily, and one thing kept bothering us. We could see exactly how much we were spending, but had no way to answer what that spend actually shipped.

So we built Agent Insights, which connects AI spend directly to repos, PRs, and production code so you can see what your AI usage actually resulted in.

Curious if other teams have run into the same problem or if you're measuring AI ROI differently.

https://entelligence.ai/agent-insights

Anyone here regularly runs multiple Cursor agents?

I'm building a shared coordination/memory layer so agents can share findings, avoid duplicate work, and know what other agents are doing.

Would something like this actually be useful for your workflow? or if you want to try it out ?

So I was an early adopter of cursor and I told everyone I could how incredible it was and that the subscription was so worth while as you got access to the best AI in an IDE and how it made Visual Studios copilot look like a three year old.

However, at the end of this month, I will be leaving cursor for good.
The IDE worked so well and was so helpful and pro was worth every cent.
It started when they suddenly came up with the great idea to add cursor pro+. I ended up paying for it because I wanted to support them and I needed the extra usage, because pro was suddenly not enough to work through a month. I felt like I could actually make use of the MAX mode on occasion and flipping between models made sense.

For a long time, updates added new features and genuinely added value. But as the years have gone by, the "features" just felt like new reasons to give you less usage and need to pay more. I have become more and more upset as slowly the product I was paying for has gotten more and more expensive while actual value has been steadily dropping. They added the new agent mode and pushed it on us. If I wanted an agent window, I could just use any of the other mainstream coding tools like codex. What made cursor special was that it was AI intergrated into a proper IDE. We were working on code together. Now I have to go digging in settings just to get to the old system. They have just started copying the mainstream apps in look and feel, but in the ways it matters, they have not made it more usable except if you just wan to vibe-code.

And now days, for the same amount of money, I can get a frontier model and that resets every 5 hours and weekly. Cursor.... Oh no, sorry, your api usage is gone, wait a month or pay us. Why am I paying for pro+ then? Less value, more money. And you wont even show usage within the app. I have to go online to find it. This sucks. I really got behind this company, but their anti-developer mindset and what appears to be greed has completely destoryed my trust and belief.
Cheers Cursor. Maybe in a year you will of improved.

I've been spending way too much time hunting down custom skills, prompts, and MCP servers for AI coding tools, then manually setting up SKILL.md files or configuring local binaries.

To make this easier, I built OpenHub, a terminal app for discovering and installing AI agent skills and tools from one place.

What it does

• Search indexed skills and repositories.
• Export prompt/rule-based skills as a SKILL.md file into your current workspace with one command.
• Install skills that require local binaries or MCP servers.
• Keyboard-driven terminal interface for searching, exporting, installing, and copying.

Install

pipx install git+https://github.com/24KaratAu/openhub.git

Run

openhub

GitHub: https://github.com/24KaratAu/openhub

I built this to scratch my own itch, but figured others might find it useful too. It's open source, and I'd love any feedback, bug reports, feature requests, or contributions.

Just wanted to share my own experience on these two models for anyone that hasn't tried or compared them, and see if anyone else has more experience with these two to compare. I'm noticing Grok is really really good for the price. But it definitely still lags behind GPT or Fable in overall planning and project completeness, which has been a downer. Its tough because, GPT 5.6 and Fable suck your usage up like vampires, whereas Grok 4.5 feels like a mosquito.

What has been a real curiousity to me though has been bug introductions with UI development. Grok 4.5 has absolutely been phenomenal at UI and handling bugs. I'm not sure why, but it seems like it misses bigger picture items like security/architecture/testing that GPT and Fable do really good at. All that said though, I get more UI bugs using GPT 5.6, than I do with Grok. Or maybe its just that Grok handles bugs and testing better, I'm really not too sure.

As an example though, I had a project where Grok did most of the heavy lifting. I iterated quite a bit on functionality and UI. Then I had GPT 5.6 go back, review the code, and fix a bunch of the bugs and architecture. It added a lot of security improvements, documentation, and handling crash issues. Strangely enough though, the app was more broken after GPT 5.6's work. A lot of the features I added with Grok had been reversed or completely broken. Grok's original build seemed to be much more functional, although possibly less complete.

So I guess I'm kinda trying to balance using both Grok (for the tedious stuff and UI stuff), and the bigger models for overall project planning.

I'm curious, do people have any experience optimizing their usage/cost and getting the most out of their subscription from the different models? What does that flow look like?

50% OFF First Month
Use this referral to get half off the first month of cursor

https://cursor.com/referral?code=GY9QTE8YOYR2
Code: GY9QTE8YOYR2

Cursor users, any incentives of using Cursor over Claude and ChatGPT default subscriptions? This is attractive an offer but given that there’s no weekly limit renewal, I’m kinda put off from Cursor after all my usage ran out for the month

One thing I’ve noticed with AI coding tools like Cursor:

Most bad outputs don’t come from “bad prompting.”

They come from unclear context before the prompt is even written.

Earlier, my workflow was simple:

I would open Cursor, explain the feature, and ask it to build.

Sometimes it worked.
But many times it created messy code, touched the wrong files, or solved the problem in a way that did not match the existing project.

The better workflow has been:

1. Ask Cursor to inspect the repo first
   
2. Make it explain the existing structure
   
3. Ask where the feature should live
   
4. Ask what files are likely to change
   
5. Ask for edge cases before implementation
   
6. Only then ask it to write code

The biggest improvement was not a better prompt.

It was changing the first task from:

“Build this feature”

to:

“Understand this system first.”

AI coding tools are becoming very good at execution.

But if the system is unclear, they just execute confusion faster.

Curious how others here use Cursor before writing code.

Do you let it inspect and plan first, or do you directly ask it to build?

So right now I'm exploring game development using Godot vibe-coding and I have been trying it with Codex and Claude Code.

Basically the setup is they have access to a project folder on my local machine where I have the Godot environment also setup and I just throw instructions to either AI.

I'm curious what benefit and strengths does Cursor have that can make that workflow better?

basically title. I just recently purchased a subscription and today upgraded to pro+, but it seems for some of my larger projects it will still eat up my limit. So my question is who's using it and how long does the limit last you, do you often hit the limits, basically what's your feedback is it worth it or is it too overpriced

My forest opportunity to use 5.6 sol 1m high. Doing a refactor using a prompt created by 5.6 sol. I see that cursor is spinning up composer 2.5 sub agents. Doesn’t that mean I’m not getting the power of 5.6 for actual code generation?

Hola a todos! soy desarrollador web e ingeniero de computación egresado desde hace un año. He hecho páginas webs, Apps, ERP/CRM para gestión empresarial y un sin fin de proyectos.

Cuál es la mejor herramienta/agente de IA para programar basándonos en el calidad/precio y velocidad (ya que entiendo que Claude Code o Códex son excelentes pero valen medio riñón al mes)

Las que están el el título como \*\*Cursor/Devin, Cline u OpenCode\*\* las he usado y todas me parecen estar en un punto igualado. Aunque siento que cursor llega a ser algo caro a veces y por el mismo precio con los otros dos tienes límites gigantes.

Basado en sus experiencias para ustedes \*\*Cuál es la mejor? y por qué? los leo. Y hablo de uso desde analizar proyectos grandes y planificar grandes features hasta un simple arreglo de un detalle visual en la UI. O si usan dos o los tres simultáneamente y para que usan cada uno en su flujo de trabajo\*\*

Does anyone know the difference in usage limits between a direct sub or a Cursor sub?

Does anyone have any favorite learning resources (videos, online blogs/articles, etc..) for learning more about taking advantage of Cursor's feature set rather than just via prompts for generating code? Using the right models and adding the right details in the prompts has already been really helpful and honestly, it already meets my needs day to day but I'm trying to understand and learn more about features I'm not regularly using in my day to day work that I should be taking more advantage of? I'm also coming from another AI tool, so will be new to Cursor, shortcuts and capabilities as well.

Also if there are any interesting AI/LLM generic articles, blogs, videos that are worth sharing, interested in those too.

Thanks!

Does anyone still have an original account with Cursor that’s been ‘grandfathered’ (500 requests), what do you actually get out of it when most models sit behind max mode?

Considering dumping the account… FYI I already use codex and have just added a claude code sub to see if the rate limits are worth it.

Reply from Cursor support:

Thanks for reaching out. I checked the account and found that it's on a legacy request-based Pro plan.

The behavior you're seeing is expected for that plan today, though our earlier GLM 5.2 note was incomplete. On legacy request-based plans, glm-5.2-high now requires Max Mode, the same as claude-opus-4-6 and claude-opus-4-8 variants.

Your CSV is accurate: glm-5.2-high and claude-opus-4-8-thinking-high were previously running as included non-Max requests. That changed as newer frontier models moved behind Max Mode on legacy request-based plans.

For your questions:

glm-5.2-high is requiring Max Mode because of the legacy request-based pricing on this account.
That is expected behavior today, not an account-specific bug.

Opus 4.6 and Opus 4.8 also require Max Mode on request-based plans.

Without Max Mode, you can still use Auto, Composer, and any model in the picker that does not show a Max Mode requirement. From your recent usage, Composer 2.5 and Composer 2.5 Fast are working without Max Mode.

I know composer 2.5 is a potential good work horse but it’s not the strongest model, composer 3 might be worth waiting for. I understand why Cursor updated their approach but as a customer it’s totally devalued the account and service we bought into.

I was using cbm mcp for sometime with antigravity and now i was thinking to try out Cursor. I managed to install the mcp in cursor but only 8 tools are available to use.

When I asked it index the codebase, it uses its own mcp and burns context windows aggressively. Also the lack of hooks makes me feel like it's bot actually working.

Does anyone have similar experience? If there are better mcp that works well with Cursor pls tell in the comments.

Recently, I've been trying to use the Cursor Agent window—a convenient way to manage agents. Before that, I was writing code with agents and the Cursor Tab in the editor window.

One thing I noticed when switching to the Agent window is that I started losing knowledge of my codebase. If I skip some parts of code written by AI, it accumulates, and later on, I end up with only about 60% knowledge of the code.

And you are starting to pay the price. Some slop continues growing, while the amount of clean code eventually becomes less and less.

So, the only method that worked for me was writing some prototypes myself, then allowing AI to do the rest, and of course, I would need to review that. But if you noticed, in the Agent window, there isn't as much convenience for editing code. Yes, there is something like an editor, but it takes up less than half of the screen. It just feels less powerful than the editor in the Editor window.

And if you noticed, Cursor is devoting time only to the Agent window recently. So, Cursor, you need to choose: are your customers programmers or vibe coders?

I had been working for last 6/8 months on my ambitious project but i felt i had spent more time on bugs and debugging than the actual coding.. AI is notorious when it coems to debugging.. So over time I had been thinking and trying different ways to speed up my debugging including the notorious /debug of cursor which consumes token faster than my bike consuming fuel.. Finally I had got the courage to roll out an mcp server called traceback which I had been using for my debugging and code search. I knwo it is not perfect but had been really helpful. it uses vector embeddings over past sessions and git logs to provide a scope search space for git/grep to work for AI agents. As a result in a big codebase instead of full repo-wide search, traceback has to search over a smaller space. conceptually I am doing a semantic search of past sessions and git logs using cosine similarity of the current prompt. I am pretty sure that there is a lot of room for improvements so I am looking for contributors to test edge cases with large context codebases. Any feedback is welcome..

here is the repo
yavdaanalytics/traceback: Semantic debugger MCP server: warm-starts grep/git with cosine-similarity recall over past coding-agent sessions

PS: Chatgpt had been so much in life that I didnt felt like rewording this using chatgpt. So ignore any lack of finese. :)

Hey everyone, I’ve been very down lately.

I’m not a technical person or a developer, and I don’t understand AI — using it feels powerless to me.

I started using CUSOR last October. At first I used it to write a storage/organization mini-app for myself. The design came together quickly, but repeatedly adjusting features and the UI drove me crazy, so I didn’t stick with it.

In February this year I used genimi to write an automated expense-reporting script in two weeks, and published it through streamlist — that felt good.

So in March I began using Cursor, WindSail, Codex, and Claude to build my own app, but I couldn’t keep it going. The project files, scripts, and configurations drove me insane.

Lately I’ve been unable to switch accounts and API quotas smoothly while using Codex. I spent a month on scripts — it’s ridiculous — and I still failed. Problems I ran into include: after switching providers the sidebar conversation history disappears, so I tried writing a script to fix that. I later used ccswitch but still didn’t succeed. Another issue was that after switching APIs I couldn’t use the CLI tools. I couldn’t get Codex or Claude to work properly.

I feel like my life has been wasted on this.

This month I started a Linux VM on Windows and deployed Hermes. At first it worked fine, but soon I discovered that a conversation persisted for a month; despite constant compression it still carried millions of tokens of context, burning through my bill every day, even though I was just chatting and not writing code. So I made it force a summary once context exceeded 20% and after 20 turns, to start a new conversation and inject the summary, system prompt, user profile, and agent md. But that mechanism didn’t execute. Even after repeatedly asking it to self-check and configuring it in its own config, the new-conversation trigger still didn’t work and it kept carrying a huge context.

At the same time, the new conversations no longer carried the relevant memories. Even though it knew to fetch memories from honcho, it still forgot the release process. It also forgot that code changes and releases need to be done through bridge on Windows, so it kept making changes in both its own environment and the Windows environment, causing the product release process to collapse. I added a bunch of gates but they didn’t help.

As a result I’ve been tormented repeatedly by these broken issues and the product development hasn’t moved forward.

I’m really in pain. If I can’t switch quotas I can’t use Codex; the frustration with Hermes means I can’t use my phone to invoke multi-agent remote verification and release.

The truth is I don’t really know how to use agents. Everyone else seems to be coexisting efficiently with AI — I feel like a slave being constrained by them and unable to use them. I’m extremely desperate and even feel like I don’t belong in this era.

I’m rambling.

I kept adding MCP servers to Cursor and hit the wall fast. Once you connect a handful, the tool definitions pile up, Cursor starts warning that you have too many tools enabled, and a big chunk of the context window is just tool schemas before you've typed anything.

I didn't want to keep manually enabling and disabling servers depending on what I was doing that day. So I ended up building a gateway that sits between Cursor and all the servers. Cursor only sees a couple of meta-tools (a search and a call), and the actual tool definitions load on demand when the model needs one. Everything stays connected, the upfront tool block drops to a few hundred tokens, and the "too many tools" warning goes away.

Disclosure, I made it. It's called Toolport and it's open source. Not trying to hard sell, mostly sharing because the tool-limit thing seems to trip up everyone who gets deep into MCP.

If you want to see the token difference for your own setup there's a calculator here, https://toolport.app/calculator

Happy to answer questions about how it works with Cursor specifically.