Cursor Review: I Paid $20/Month for 90 Days — Here’s What Actually Happened
I switched to Cursor three months ago after eight months on GitHub Copilot. The pitch: an AI-native code editor that doesn’t just autocomplete — it reads your entire codebase and writes multi-file changes on command.
After 90 days and 47 production commits generated with Cursor’s help, here’s what I learned: it’s good at mechanical refactoring work if your project is large enough that context matters. If you’re writing isolated functions or learning to code, you won’t use the features that justify the price.
What Is Cursor?
Cursor is a fork of VS Code with AI built in from the ground up. Same extensions, same keybindings, same interface — but instead of bolting on autocomplete as a plugin, they rebuilt the editor around it.
The main feature is Composer. You describe what you want changed, and Cursor generates diffs across multiple files. It indexes your codebase, understands dependencies, and can write multi-file refactors in one pass.
That’s the theory. The practice has rough edges.
Cursor Pricing Breakdown
Three tiers:
Free (Hobby) — 2,000 completions per month, 50 slow premium requests. Basic autocomplete but not full Composer access. Fine for testing, not for real work.
Pro ($20/month) — Unlimited completions, 500 fast premium requests (GPT-4 or Claude Sonnet), then unlimited slow requests after that. This is the tier most people land on.
Business ($40/user/month) — Centralized billing, admin controls, enforced privacy mode. Only worth it if your company requires it.
The catch: 500 fast requests sounds generous until you actually use Composer. A single refactor can burn 10-15 requests if you iterate. I hit my limit by day 18 in month two.
Once you drop to slow requests, responses take 15-30 seconds instead of 3-5. Still usable, but the flow breaks.
What I Actually Used It For
I work on a SaaS dashboard (Next.js, TypeScript, Supabase). Here’s what Cursor handled:
Refactoring a component library — I asked it to convert 12 files from CSS modules to Tailwind. It did the conversion but broke two responsive breakpoints I had to fix manually. Saved time overall, but required review.
Database schema migrations — Described a change to user roles in plain English. Cursor generated the SQL migration, updated the TypeScript types, and modified the affected API routes. Worked on the first try.
Bug fixes — Pasted an error stack trace, asked what broke. It found the issue (an async race condition in a useEffect hook) and suggested a fix that worked.
Boilerplate code — Asked it to scaffold an admin CRUD page. Generated the form, table, and API endpoints in about 90 seconds. Needed minor style tweaks but saved me an hour.
Complex business logic — Asked it to implement a tiered subscription calculator with tax handling. First pass was close but had edge-case bugs. Took three iterations to get right.
The pattern: Cursor is faster than doing mechanical work manually. Refactors, schema changes, boilerplate — it handles these well. For logic that requires judgment or domain knowledge, it gives you a starting point, not a solution.
The Good: What Cursor Does Better
Codebase Context Actually Works
GitHub Copilot sees one file at a time. Cursor indexes your entire project. When I ask it to “add authentication to the dashboard,” it knows where my auth utilities live, what my user model looks like, and which routes need protecting.
That context awareness is the reason to use Cursor. Without it, you’re paying $20/month for autocomplete.
Multi-File Edits Work
Composer can edit 5-10 files in one go. I used it to rename a core API endpoint — it updated the route definition, all the frontend calls, the tests, and the documentation. Saved me 20 minutes of find-and-replace mistakes.
The UI Doesn’t Fight You
Copilot’s inline suggestions cover your code and require constant tabbing through. Cursor shows suggestions in a side panel. You can review, edit, or reject them without breaking your flow. Small detail, but it matters when you’re in deep focus.
Model Switching Is Built In
You can toggle between GPT-4, Claude Sonnet, and other models mid-conversation. Claude handles large refactors better; GPT-4 is faster for small fixes. Having both available without switching tools is useful.
Chat History Persists Per Project
Every conversation is saved and searchable. I found myself referencing old chats when revisiting a feature weeks later. GitHub Copilot Chat forgets everything the moment you close it.
The Bad: Where Cursor Falls Short
The 500-Request Limit Hits Fast
If you use Composer daily, you’ll hit the fast request cap in 2-3 weeks. After that, slow requests make the tool feel sluggish. For $20/month, the cap feels arbitrary.
It Hallucinates Library APIs
Cursor confidently invented a useAuthRedirect() hook that doesn’t exist in my auth library. I caught it because I knew the codebase. If you’re less familiar with your dependencies, you’ll ship bugs.
Always review suggested code. The editor makes it easy to trust the output blindly. Don’t.
No Built-In Testing
Cursor will write tests if you ask, but it won’t run them. You still need to switch to your terminal. For a tool that markets itself as AI-native, the lack of integrated test execution is a gap.
Overkill for Small Projects
If you’re building a landing page or a simple CRUD app, Cursor’s context features don’t matter. You’re paying for capabilities you won’t use. Free Copilot or Cody will do the job.
Vendor Lock-In Risk
Cursor is a startup. If they get acquired or pivot, you’re migrating back to vanilla VS Code. Not a dealbreaker, but worth keeping in mind if you’re committing to this as your primary editor.
Cursor vs GitHub Copilot: The Real Comparison
I used Copilot for eight months before switching. Here’s how they stack up:
Feature Cursor Pro GitHub Copilot Pricing $20/month $10/month (or $100/year) Autocomplete Quality Slightly better Good enough Multi-File Edits Yes (Composer) No Codebase Context Full project indexing Single file Model Options GPT-4, Claude, custom GPT-4 only IDE Integration Native (Cursor is the IDE) Plugin (VS Code, JetBrains, etc.) Request Limits 500 fast/month, then slow Unlimited Learning Curve Minimal (it’s VS Code) None
Cursor wins if you refactor often, your project is large enough that context matters, and you value speed over cost.
For me, Cursor is worth the extra $10 because Composer saves me 3-5 hours per week. If I were writing smaller scripts or bouncing between projects constantly, I’d stick with Copilot.
Who Should Actually Buy Cursor
You should buy Cursor if you’re refactoring or maintaining a mid-to-large codebase where context matters, you iterate on features frequently and need multi-file edits, you value flow state and hate context-switching, and $20/month is worth 3-5 hours saved per week.
Skip Cursor if you’re learning to code (too much handholding slows skill development), you’re building small one-off projects, you already have a workflow that works, or you need unlimited AI requests (the 500-cap will frustrate you).
The deciding factor: if you’ve ever thought “I wish Copilot understood my entire project,” Cursor solves that. If that sentence doesn’t resonate, save your money.
FAQ
Is Cursor better than GitHub Copilot? For multi-file refactors and projects where codebase context matters, yes. For isolated scripts or if you want unlimited requests, Copilot works fine. Cursor costs twice as much but saves me 3-5 hours per week, so the math works out.
Does Cursor work offline? No. All AI features require an internet connection. Autocomplete will fail if you’re offline. If you code on planes or in areas with spotty internet, this is a problem.
Can I use Cursor with my existing VS Code extensions? Yes. Cursor is a fork of VS Code, so most extensions work. I migrated my setup in under 10 minutes. The only exceptions are extensions that conflict with Cursor’s built-in features (like other AI autocomplete tools).
What happens after I hit the 500 fast request limit? You drop to slow requests, which use less expensive models and take 15-30 seconds instead of 3-5. You still get unlimited slow requests, but the experience degrades. If you consistently hit the cap, you’ll need to budget your Composer usage more carefully.
Is my code sent to OpenAI or Anthropic? Yes, unless you enable Privacy Mode (Business plan only). Cursor’s AI features require sending code snippets to their model providers. If you work on proprietary or sensitive codebases, the Business plan’s enforced privacy controls are worth considering.
Can I use Cursor for free long-term? Technically yes, but the 2,000 completion limit and 50 slow premium requests make it impractical for daily use. The free tier works for evaluating whether Cursor fits your workflow before committing to Pro.
Final Verdict
Cursor works well for a specific use case: mid-to-large projects where multi-file refactors and codebase context provide real value.
If that matches your workload, the $20/month pays for itself in saved time. If you’re writing scripts, learning to code, or working on simple projects, you won’t use the features that justify the price.
I’m keeping my subscription because the hours saved on refactors make it worthwhile. But I’d recommend most people start with the free tier or stick with GitHub Copilot until they hit a pain point Cursor actually solves.
Rating: Good tool for the right job. Not a universal upgrade.
