- My project: Hermes IDE | GitHub
- Me: gabrielanhaia
The AI coding tool that promised to 10x developer productivity just quietly deleted an afternoon's work. Then it charged for the privilege.
That's not hyperbole. That's a Tuesday for Cursor 3 users who've been filing bug reports, comparing billing screenshots, and watching their model settings rearrange themselves overnight. What shipped as an "agent-first" IDE looks more like a trust-destruction machine wearing a VS Code skin.
The Bug That Should've Blocked the Release
Picture this. A developer writes code. Cursor's agent mode makes edits. Everything checks out. Then the developer spots something minor, clicks "Fix in Chat," and the agent takes care of it.
Except when they flip back to their file, their previous changes are gone.
Not flagged. Not conflicting. Not sitting in some recovery panel. Gone. The file quietly reverted to its pre-agent state while nobody was looking.
The root cause sits in a conflict between the Agent Review Tab and the main editor state. When both are active and a developer triggers "Fix in Chat," Cursor overwrites the file with the older version. No diff notification. No undo prompt. The edits vanish like they never happened.
Here's the kicker: this isn't some obscure edge case requiring a bizarre reproduction sequence. The "Fix in Chat" button sits right there in the UI. The Agent Review Tab opens automatically. Using both in sequence is the workflow Cursor's own interface encourages. It's the happy path. And it destroys work.
A code editor that silently deletes changes has broken the most basic contract between a tool and the person relying on it. Bugs ship. Silent data loss ships differently.
Workarounds (That Shouldn't Be Necessary)
These aren't fixes. They're defensive coding against a paid product.
Close the Agent Review Tab before clicking "Fix in Chat." This is the big one. Manually closing that tab before sending any follow-up prompt to the agent prevents the revert. Yes, that means avoiding a core feature to stop the product from eating code.
Commit like a paranoid junior dev. Small, frequent git commits become restore points. When Cursor silently reverts something, git diff reveals what vanished and git checkout brings it back.
# Run this in a separate terminal to catch silent reverts
watch -n 5 'git diff --stat'
Keep an external diff monitor running. A terminal with git diff --stat on a loop or a tool like delta watching for unexpected file changes acts as a canary. If a file suddenly shows modifications nobody made, something went wrong.
Some users report that disabling the review tab through settings prevents the revert bug altogether. The tradeoff: losing a significant chunk of Cursor's agent workflow. That's a functionality sacrifice no paying customer should have to make, but it works. Check Settings > Features > Agent and look for review-related toggles. Naming varies between versions.Disable the Agent Review Tab entirely
Agent Mode and the $2,000 Week
Old Composer was predictable. One request, one response, done. Agent mode works on a completely different cost model. It chains multiple calls together: planning steps, executing them, reviewing results, iterating. Each link in that chain burns tokens.
Developers reported $2,000 in charges across just two days. Not two months. Not even two weeks. Two days. And they weren't running some absurd stress test. They were using agent mode the way Cursor's own demos showed it being used.
Making it worse, Cursor has been quietly tightening request limits each quarter. What started as generous early-adopter allocations keeps shrinking, shoving more users into overage billing territory.
What It Actually Costs: Tool Comparison
| Feature | Cursor Pro | Claude Code | GitHub Copilot | Windsurf |
|---|---|---|---|---|
| Base price | $20/mo | $20/mo (Max plan) | $10–19/mo | $15/mo |
| Agent/agentic mode | Included (capped) | Terminal-native agent | Copilot Chat | Cascade |
| Overage model | Pay-per-request past cap | API usage billing | Flat rate, no overage | Tiered limits |
| Typical heavy-use week | $100–$2,000+ | $50–$200 | $10–$19 (fixed) | $15–$60 |
| Cost predictability | Low | Medium | High | Medium-High |
| Hard spending cap | Buried in dashboard | API budget controls | N/A (flat rate) | Tier-based |
That "$2,000+" isn't a typo or a worst-case scenario invented for drama. It's a real number from real users doing real work. Cursor is the only tool on this list where weekly costs can spike by an order of magnitude without warning.
Locking Down the Billing
Cursor doesn't make cost controls obvious. Here's where to find them:
- Open the web dashboard (not editor settings). Go to Settings > Billing
- Look for usage caps. Set a hard monthly maximum if one exists
- Monitor the Usage tab daily for at least the first two weeks of agent mode
- For routine edits, skip agent mode entirely. Standard autocomplete and inline chat handle most tasks without triggering multi-step chains
Pro tip: Set a calendar reminder to check billing every 48 hours.
Annoying? Yes. Cheaper than the alternative? Absolutely.
The deeper problem isn't just that agent mode costs more. It's that costs are unpredictable. A simple refactor might take three agent steps one day and eleven the next, depending on how the planner interprets the codebase. With autocomplete, costs track keystrokes. With agent mode, costs track the model's internal reasoning, which nobody can forecast.
The Moonshot AI Problem
TechCrunch reported in early 2026 that Cursor's Composer 2 model was built on top of Moonshot AI's Kimi 2.5. Moonshot AI is a Chinese AI company. Plenty of excellent research comes from Chinese labs. That's not the issue.
The issue is that Cursor told nobody.
Developers paying $20–$40/month had every reason to believe they knew what models were processing their code. Cursor's settings page shows model names. Users pick between Claude, GPT-4, and other options. What they didn't pick, because they were never given the choice, was a fine-tuned version of Kimi 2.5 running under a different label.
For compliance teams, this is a five-alarm fire. Organizations that approved Cursor based on Anthropic and OpenAI model usage might have a very different answer for Moonshot AI. Where do prompts go when Composer 2 handles them? Through Cursor's servers only, or do they touch Moonshot AI infrastructure? Without disclosure, there's no way to audit.
If a company will quietly swap out the model powering its flagship feature, what else changes without announcement? That question sits at the center of every trust conversation around Cursor right now. And the company still hasn't answered it.
The Smaller Cuts That Bleed Trust
Headlines go to the silent revert and the billing explosions. But Cursor 3 shipped with a whole collection of paper cuts that make the trust problem feel systemic.
The "Review Next File" crash. Clicking this button in the agent review flow crashes the application. Not sometimes. Reliably. Users lose their in-progress review state and, depending on timing, uncommitted changes too. A core navigation button in a core feature, and it crashes the app. That shipped to production.
Model settings resetting to "auto." Developers have opened Cursor to find their hand-picked model preferences silently flipped back to "auto." Someone who chose Claude 3.5 Sonnet for its coding strengths could be routed to whatever Cursor's auto-selection algorithm picks. Given the Moonshot AI situation, a setting that changes itself carries implications far beyond "annoying UI bug."
Compound failure. Any single one of these is forgivable. Software ships bugs. Billing gets messy. Partnerships evolve. But when all of it lands simultaneously, in the same release, on paying customers, the pattern stops looking like growing pains and starts looking like a product that shipped months before it was ready.
Verify Model Settings Right Now
This takes sixty seconds and might save hours of confusion.
Step 1: Open Cursor > Settings (gear icon, bottom left)
Step 2: Navigate to Models or AI Settings
Step 3: Check the Default Model dropdown
Step 4: If it says "auto" and that's not what was set, it was reset
Step 5: Explicitly select the preferred model. Screenshot the selection.
Step 6: Check again in 48 hours. If it reverted to "auto," the bug is active.
For teams: a more thorough audit process
For anyone doing this check right now: also look at the Composer Model or Agent Model setting if it exists separately from the chat model setting. That's where the Moonshot AI-sourced model reportedly operates, and it might be configured differently from what the main settings page suggests.
Why Cursor Is Breaking Things
This isn't carelessness. It's panic.
Claude Code captured roughly 54% of the AI-assisted coding market. That number reshaped the competitive map overnight. Anthropic's approach turned out to be what a huge segment of developers actually wanted: a terminal-native agent that works with existing tools rather than replacing the editor.
Cursor's response was a hard pivot toward "agent orchestrator" territory. That pivot is Cursor 3. Agent-first design, multi-step workflows, the Review Tab, Composer 2. All of it is an attempt to compete with Claude Code's agentic approach from inside a VS Code fork.
On a whiteboard, the strategy makes sense. In production, it shipped half-baked. Features that needed three more months of testing went live because the competitive window felt like it was closing. Power users built Cursor's reputation through word-of-mouth. Those same power users are now the ones absorbing the damage.
Several long-time Cursor advocates have publicly described feeling abandoned as the product moves away from the refined autocomplete-and-chat experience that made it popular. They signed up for the best AI-powered code editor. What they got was an agent orchestrator with a reliability problem. Those are different products with different quality bars.
What Needs to Happen
Cursor has a narrow window to recover.
The silent revert bug needs a fix measured in days, not sprint cycles. The billing model needs a hard spending cap that's visible before charges pile up. The Moonshot AI sourcing needs a retroactive disclosure: what model runs where, where code data flows, and who has access.
Most importantly, model settings need to stay where users put them. When a developer selects Claude Sonnet, that selection should hold until the developer changes it. Not "auto." Not quietly rerouted. Locked.
The developer tools market has never offered more alternatives. GitHub Copilot keeps iterating. Windsurf is gaining traction on simplicity and price. Claude Code is expanding its terminal-native approach. Switching costs for an editor extension hover near zero.
Cursor built its user base on being the AI editor that "just worked." Version 3 has put that reputation in critical condition. The bugs are fixable. The billing model is adjustable. Trust, once broken, rebuilds on a much longer timeline.
For now, the practical advice is blunt: commit constantly, verify model settings on a schedule, monitor billing like it's a production dashboard, and keep a backup editor configured and ready. No developer tool should require that level of defensive behavior from its paying users.
But here we are.
Top comments (1)
Exactly why do folks even continue to use cursor, just uninstall it and move on to Claude code or Droids