Back to all essays
AI First

Cursor Review: How I Write 10x More Code (After 6 Months)

·6 min read
George Pu
George Pu$10M+ Portfolio

27 · Toronto · Building businesses to own for 30+ years

Work with meAbout
Cursor Review: How I Write 10x More Code (After 6 Months)

I've used Cursor for 6 months. Written 50K+ lines of code with it. Built SimpleDirect Desk in 3 weeks instead of 3 months.

Cost: $20/month. Value: Replaced what would've been a $120K/year senior dev.

Not hyperbole. Here's exactly how I use it, what it can't do, and who should skip it entirely.

What It Actually Does (Not the Marketing Copy)

Cursor is an AI-first code editor. Think VS Code, but the AI understands your entire codebase and writes code like a senior developer who's been on your team for years.

Core Features I Actually Use:

  • Codebase-wide AI assistant: Ask questions about any part of your code
  • Context-aware code generation: Writes functions based on existing patterns
  • Intelligent autocomplete: Predicts entire code blocks, not just variables
  • AI-powered debugging: Explains errors and suggests fixes
  • Code refactoring: Rewrites sections for better performance/readability

What Makes It Different from GitHub Copilot:

  • Understands your entire project context (not just current file)
  • Can reference documentation and patterns across files
  • Asks clarifying questions when requests are ambiguous
  • Suggests architectural improvements, not just code completion

Honest Limitations:

  • Doesn't understand business logic (you still need to know what to build)
  • Occasionally suggests outdated patterns
  • Can't replace product/design decisions
  • Requires code review (AI makes subtle mistakes)
  • Works best with well-structured codebases

How I Use It: Real Workflows

Workflow 1: Building New Features (SimpleDirect Desk Example)

The Task: Add automated credit scoring to SimpleDirect Desk

  • Integrate with 3 credit APIs
  • Handle API failures gracefully
  • Cache results for 24 hours
  • Add admin dashboard view

Traditional Approach (Estimated):

  • Research APIs: 4 hours
  • Write integration code: 16 hours
  • Error handling: 8 hours
  • Caching implementation: 6 hours
  • Admin dashboard: 12 hours
  • Total: 46 hours (6 days)

With Cursor (Actual):

  • Research APIs: 2 hours (Cursor explained API docs)
  • Write integration code: 4 hours (Cursor wrote boilerplate)
  • Error handling: 2 hours (Cursor suggested patterns)
  • Caching implementation: 1 hour (Cursor wrote Redis logic)
  • Admin dashboard: 3 hours (Cursor built React components)
  • Total: 12 hours (1.5 days)

Time Saved: 34 hours (74% reduction)

Workflow 2: Debugging Complex Issues

Real Example: SimpleDirect Core had a race condition causing duplicate loan applications.

My Process:

  1. Describe the problem to Cursor: "Users sometimes create duplicate loan applications when they click submit twice quickly"
  2. Cursor's analysis: Identified potential race conditions in 3 files, suggested adding request deduplication
  3. Implementation: Cursor wrote the deduplication middleware in 10 minutes
  4. Testing: Cursor generated test cases for the race condition

Traditional Debugging:

  • Would've taken 4-6 hours of console logging and head-scratching
  • Might not have found the root cause immediately

With Cursor:

  • 30 minutes from problem description to tested fix
  • Time Saved: 5+ hours

Workflow 3: Code Refactoring

The Challenge: SimpleDirect's authentication system was spread across 8 files with lots of duplication.

Cursor's Approach:

  1. Analyzed the codebase: "Can you identify authentication-related code duplication?"
  2. Suggested refactoring plan: Proposed a centralized auth service
  3. Generated implementation: Wrote the new auth service with proper typing
  4. Updated all references: Modified 8 files to use the new service
  5. Added tests: Generated comprehensive test suite

Time Investment:

  • Traditional refactoring: 2-3 days (risky, error-prone)
  • With Cursor: 4 hours (systematic, tested)

Result: 40% reduction in auth-related code, better maintainability, fewer bugs.

Workflow 4: Learning New Technologies

Scenario: Needed to integrate WebRTC for SimpleDirect's video verification feature.

Traditional Learning Curve:

  • Read documentation: 4 hours
  • Follow tutorials: 6 hours
  • Debug setup issues: 8 hours
  • Build working prototype: 12 hours
  • Total: 30 hours

With Cursor:

  • "Explain WebRTC in the context of React applications"
  • "Write a video chat component using WebRTC"
  • "Add screen sharing to this component"
  • "Handle connection failures gracefully"
  • Total: 6 hours

The Difference: Cursor explained concepts while building, not separately.

he ROI Calculation (My Numbers)

Investment

Cost:

  • Cursor Pro: $20/month ($240/year)
  • Learning curve: ~5 hours (reading docs, setting up)
  • Migration from VS Code: ~2 hours
  • Total first year: $254

Return

Value Created (6 Months):

SimpleDirect Desk Development:

  • Built in 3 weeks vs estimated 3 months
  • Time saved: ~280 hours
  • At my billing rate ($200/hour): $56K value

SimpleDirect Core Improvements:

  • Authentication refactor: 20 hours → 4 hours (16 hours saved)
  • API integration features: 40 hours → 12 hours (28 hours saved)
  • Bug fixes and debugging: ~50 hours saved over 6 months
  • Total time saved: 94 hours = $18.8K value

ANC Platform Features:

  • Built admin dashboard: 30 hours → 8 hours (22 hours saved)
  • Payment processing integration: 16 hours → 4 hours (12 hours saved)
  • Total time saved: 34 hours = $6.8K value

Total 6-Month Value: $81.6K 6-Month Investment: $127 ROI: 642x

The Productivity Multiplier

Code Output Analysis:

  • Pre-Cursor: ~200 lines of quality code per day
  • With Cursor: ~800 lines of quality code per day
  • Multiplier: 4x raw output

But It's Not Just Volume:

  • Higher code quality (Cursor suggests best practices)
  • Fewer bugs (AI catches common mistakes)
  • Better architecture (AI suggests improvements)
  • Faster learning (AI explains as it builds)

The Real Win: I can now build ideas at the speed of thought.

Cursor vs GitHub Copilot: Head-to-Head

I used GitHub Copilot for 18 months before switching to Cursor. Here's the honest comparison:

Code Completion Quality

GitHub Copilot:

  • Good at line-by-line suggestions
  • Limited to current file context
  • Sometimes suggests outdated patterns
  • Rating: 7/10

Cursor:

  • Understands entire codebase context
  • Suggests architectural improvements
  • Learns from your coding style
  • Rating: 9/10

Winner: Cursor (by a lot)

Learning Curve

GitHub Copilot:

  • Works immediately (tab to accept)
  • No configuration needed
  • Learning time: 30 minutes

Cursor:

  • Need to learn chat interface
  • Setting up codebase context
  • Learning time: 3-4 hours

Winner: GitHub Copilot

If you're finding this useful, I send essays like this 2-3x per week.
·No spam

Context Awareness

Real Test: "Add validation to the user signup form"

GitHub Copilot Response:

javascript

// Generic validation
if (!email) return "Email required";
if (!password) return "Password required";

Cursor Response:

javascript

// Understood our existing validation patterns
import { validateEmail, validatePassword } from '../utils/validation';
import { showToast } from '../components/Toast';

const validateSignup = (userData) => {
  const emailValidation = validateEmail(userData.email);
  if (!emailValidation.isValid) {
    showToast(emailValidation.message, 'error');
    return false;
  }
  
  const passwordValidation = validatePassword(userData.password);
  if (!passwordValidation.isValid) {
    showToast(passwordValidation.message, 'error');
    return false;
  }
  
  return true;
};

Winner: Cursor (understands existing patterns)

Cost Comparison

GitHub Copilot:

  • Individual: $10/month
  • Business: $19/month per user

Cursor:

  • Free tier: Limited usage
  • Pro: $20/month
  • Business: $40/month per user

Value per Dollar:

  • Copilot: Good autocomplete for $10
  • Cursor: AI pair programmer for $20

Winner: Cursor (2x better for 2x price = same value, but Cursor's ceiling is higher)

When to Choose Each

Choose GitHub Copilot if:

  • You're happy with VS Code
  • You want simple autocomplete
  • You're just getting started with AI coding
  • Budget is tight

Choose Cursor if:

  • You want AI to understand your entire project
  • You build complex features regularly
  • You're willing to learn new workflows
  • $20/month isn't a constraint

When to Use It (And When to Skip It)

✅ Use Cursor If:

You write code regularly (5+ hours/week)

  • ROI calculation works out
  • Learning curve worth the investment

You know what you want to build

  • Cursor accelerates implementation
  • Doesn't help with product decisions

You're willing to review AI suggestions critically

  • AI makes subtle mistakes
  • Need to catch architectural issues

You want to learn while building

  • Cursor explains as it codes
  • Great for picking up new technologies

You build full applications (not just scripts)

  • Codebase context is valuable
  • Architectural suggestions matter

❌ Skip Cursor If:

You're not technical

  • Won't help you learn programming from scratch
  • Need to understand code before AI can help

You don't know what to build

  • Cursor won't make product decisions
  • Can't replace business/design thinking

You write <5 hours of code per month

  • Not worth the learning curve
  • $20/month too expensive for occasional use

You're in a highly regulated industry

  • Need to review every line carefully
  • Compliance requirements may conflict

You're happy with simple autocomplete

  • GitHub Copilot might be sufficient
  • Don't need advanced features

Advanced Tips (After 6 Months)

Configuration That Matters

Essential Settings:

  • Enable codebase indexing (performance hit but worth it)
  • Set up custom instructions for your coding style
  • Configure keyboard shortcuts for chat
  • Enable auto-save (AI works better with saved context)

Custom Instructions I Use:

- Follow our existing TypeScript patterns
- Use our error handling utilities
- Prefer functional components in React
- Add JSDoc comments for complex functions
- Import from our design system components

Prompt Engineering for Code

Bad Prompt: "Make this better" Good Prompt: "Refactor this function to use async/await instead of promises and add error handling for API failures"

Bad Prompt: "Add authentication" Good Prompt: "Add JWT authentication to this Express route using our existing auth middleware from middleware/auth.js"

Integration with Existing Workflow

My Current Stack:

  • Cursor (main editor)
  • GitHub (version control)
  • Linear (issue tracking)
  • Figma (design handoff)

Workflow:

  1. Pick up Linear task
  2. Ask Cursor to analyze requirements
  3. Get implementation plan from AI
  4. Build with AI assistance
  5. Review and test
  6. Ship to production

The Verdict: Keep or Kill

Keep. Cursor is the best $20/month I spend.

Why:

  • 4x productivity increase (measured)
  • Better code quality (AI catches mistakes)
  • Faster learning (explains while building)
  • Architectural improvements (suggests better patterns)

Alternative Options:

  • GitHub Copilot: Good starter option ($10/month)
  • CodeWhisperer: Free but limited
  • Tabnine: Privacy-focused alternative
  • Stay with VS Code: If budget is tight

My Recommendation: If you're a technical founder building products, Cursor is a no-brainer. $20/month for 4x productivity is the best deal in tech right now.

If you're non-technical, learn to code first. Then use Cursor to accelerate.

The Bottom Line: Cursor doesn't replace coding skill. It amplifies it. If you can code, Cursor makes you a 10x developer. If you can't code, Cursor won't help.

But if you're building products and writing code regularly, this tool will change how you work.

Get Cursor Pro: cursor.sh (use my referral link if this review helped)