How I write code using Cursor

Original Article ↗ Hacker News Discussion ↗

AI-powered coding tools like Cursor are reshaping how developers work, with many reporting large productivity gains on boilerplate, tests, and glue code while they focus more on architecture and product decisions. Others remain skeptical, arguing that current models struggle with complex, context-heavy changes in large or legacy codebases, can encourage shallow understanding, and raise concerns around privacy, proprietary lock-in, and long-term skill erosion—especially for juniors. Comparisons with GitHub Copilot, JetBrains AI and open-source alternatives suggest Cursor’s tight IDE integration and multi-file awareness feel like a genuine step forward for some, but far from a drop‑in replacement for experienced engineering judgment.

Perceived benefits of Cursor / LLM coding tools

  • Major time-saver for boilerplate, glue code, tests, simple CRUD, API wrappers, UI scaffolding, and repetitive data-munging.
  • Lets many devs “think at architecture level” and stay in flow instead of context-switching to docs, search, or Stack Overflow.
  • Especially helpful when exploring unfamiliar languages/libraries (e.g., Rust testing libs, Web APIs, SQL dialects, React/Next stacks).
  • Tab-completion and multi-file edits are praised for “next action” suggestions (e.g., updating all call sites after a signature change).
  • Some report completing small apps or games in a fraction of the time, spending most effort on product design and testing.
  • Strong use case as a smarter search/assistant: explaining errors, sketching options, generating commands for tools like pandoc or jq.

Concerns and limitations

  • Accuracy drops sharply for unique, business-heavy or messy problems (e.g., complex banking integrations, basket pricing rules).
  • Tends to generate “average”, tutorial-like code: misses edge cases, may use deprecated APIs, and can balloon complexity during debugging.
  • Large, legacy or monorepo codebases remain challenging: limited context, weak understanding of conventions, risk of duplication and wrong abstractions.
  • Some find inline suggestions visually distracting or overly aggressive, feeling like “another person touching my code.”
  • Multi-step autonomous workflows (e.g., Cline running tests and editing) can be impressive but also risky and prone to subtle misunderstandings.

Impact on learning and developer skill

  • Split views:
    • Pro: offloads tedious work, lets experienced devs focus on design, and can even surface simpler solutions or tests they’d miss.
    • Con: risks “skill atrophy” and stunted growth for juniors who never struggle through fundamentals or read docs deeply.
  • Many emphasize that LLM output must be reviewed like a junior’s code; it doesn’t replace understanding.

Comparisons and ecosystem

  • Cursor seen by fans as a “next generation” over Copilot: deeper repo indexing, multi-file edits, tuned models, and better completions.
  • Others feel VS Code + plugins (Copilot/Continue/Supermaven/Cline) or JetBrains + AI are equivalent or preferable.
  • Context/RAG strategies help but don’t fully solve “grok the whole system” problems; long context alone not sufficient.

Organizational & ethical issues

  • Strong concern about sending proprietary code to third-party servers; some companies ban such tools, others allow them widely.
  • Environmental cost of LLMs is raised by a few as a reason not to use them for trivial tasks.