I use Cursor daily - here's how I avoid the garbage parts

Original Article ↗ Hacker News Discussion ↗

AI Editing Behavior and Context Problems

  • Multiple reports of Cursor (and similar tools) undoing manual fixes, reintroducing deprecated APIs, and ignoring nullish coalescing or other deliberate changes.
  • Root cause is often stale or partial view of files: agent/apply models write over current code instead of re-reading it every time.
  • Users find agent mode eager to rewrite large swaths of a codebase for a small bug, leading some to disable agents and apply changes step-by-step.
  • As projects grow, tools struggle with context limits: they miss manual edits, produce broken commits, and become incoherent on mature, complex systems.

Business Model, Cost, and Incentives

  • Concern that a flat $20/mo “unlimited” plan pushes Cursor to minimize tokens via aggressive context pruning and limited “thinking,” degrading reasoning models.
  • attached-file API-style access (function calls to selectively read files) can cause planning on incomplete context, leading to speculative or incoherent edits.
  • Others note Cursor already has quotas and usage-based overages; they see optimization driven as much by “finding the right context strategy” as by cost.
  • Pay‑per‑token tools (Claude Code, Cline, Windsurf) are seen as having the opposite incentive: easy to chew through large contexts and user budgets.

Productivity vs Quality and Skill Atrophy

  • Many feel faster in the short term but see more subtle bugs leaking into PRs, especially in tests and boilerplate. Some revert to “vanilla” editors.
  • Several describe shifting from “ahead of the code” (designing) to “behind the code” (PR reviewer of AI output), which is more tiring and less engaging.
  • Strong consensus that assistants are best for small, localized edits, scaffolding, and boilerplate—not for deep refactors or complex data modeling.
  • Widespread worry that juniors relying on AI skip the hard thinking; parallels drawn to students acing homework with LLMs but failing exams.

Workflows and “Safe” Usage Patterns

  • Many successful users avoid full agentic flows; they prefer: one file at a time, small functions/classes, frequent manual review, and iterative prompts.
  • Rules and project docs (cursor rules, context markdowns) help constrain over-editing and enforce style, DRYness, and typing discipline.
  • Some split responsibilities across models: e.g., reasoning/planning with one model, implementation/refinement with another.
  • Advice: use AI to speed up what you already understand (e.g., generate 80% solutions, then finish/refactor yourself).

Privacy, Security, and Local Models

  • Serious concern about secrets: reports of .env and other sensitive files being sent in plain text; .cursorignore behavior has been evolving but not fully trusted.
  • Some are uncomfortable sending proprietary code to third parties at all and ask for reliable “local only” workflows; others note that top closed models still outperform most local ones.
  • Discussion of high hardware requirements for SOTA reasoning models vs pragmatic smaller/distilled or code-specialized models on local GPUs.

Tool Comparisons and UX Complaints

  • Alternatives frequently praised: Cline, Claude Code, Windsurf, Aider, Continue, Neovim plugins, Copilot; each has different tradeoffs in context, cost, and UX.
  • Windsurf is seen by some as more disciplined in checking usages and verifying changes; others report credit-draining loops there too.
  • Cursor catches flak for forking VS Code (breaking some extensions), overwriting the code CLI alias on update, removing self-API-key chat, and recent regressions (agent quality, search removal).

Broader Concerns and Long-Term Effects

  • Environmental and economic worries about massive GPU usage and “AI everything” despite prior “go green” promises.
  • Fear of an upcoming era of “AI slop” codebases with few strong “old-school” seniors to maintain them.
  • Debate over whether this is just another tool like calculators/StackOverflow or a qualitatively different shift in how people learn and reason about code.