The Promise
Every developer I know is talking about Cursor. It's being called "the end of coding as we know it." As someone who directs films, runs a production company, and builds web projects on the side, I was skeptical. I've seen too many tools promise to replace skilled work, only to create a different kind of work.
But I've been using Cursor as my primary development environment for the past month. I built and maintain the entire Open Your AIs website with it. Here's what actually happened — from the perspective of a non-developer who codes out of necessity.
What It Does
Cursor is a code editor (forked from VS Code) with deeply integrated AI capabilities. It's not a chatbot that writes code when you ask — it's an editor that understands your entire codebase and can modify it based on natural language instructions.
Key features:
- Codebase awareness: Cursor indexes your entire project and understands how files relate to each other. When you ask it to modify a component, it knows which other files are affected.
- Chat + Apply: Describe what you want in plain English. Cursor generates the code and shows you a diff. Accept it, reject it, or modify it.
- Agent mode: Give Cursor a higher-level task — "add a dark mode toggle to the site" — and it plans and executes multiple file changes autonomously.
- Tab completion: As you type, Cursor predicts your next lines based on context. Not generic autocomplete — context-aware predictions that understand what you're building.
- Inline editing: Select a block of code, describe what you want changed, and Cursor rewrites it in place.
Real-World Test
I didn't test Cursor with toy projects. I used it for real work that ships to real users. Here are four scenarios from the past month:
Test 1: Building a Complete Article System
Open Your AIs needed a new article management system — article pages, category filtering, tag navigation, search functionality, and SEO optimization. I described the requirements to Cursor in plain English across several sessions.
Result: Cursor built a functional article system in about 3 days of part-time work. The component structure was clean, the routing worked, and the SEO implementation was solid. What would have cost me $3,000-$5,000 to hire a developer for was done for $20 (my Cursor subscription).
The caveat: I had to make 20-30 corrections along the way. Cursor would occasionally implement something that technically worked but wasn't what I meant. The specificity of my descriptions improved over time — I learned to speak "Cursor" the way I learned to speak "Midjourney."
Test 2: Refactoring Legacy Code
I had old website code from 2019 that I was genuinely afraid to touch. Spaghetti JavaScript, inline styles, no component structure. Cursor refactored an entire component library in an afternoon — extracting components, creating proper interfaces, converting inline styles to CSS modules.
This would have taken me a week of careful manual work. Cursor did it in 4 hours. And the code was cleaner than what I would have written myself, because it followed modern patterns that I hadn't learned yet.
Test 3: Debugging a Production Issue
A routing bug was causing 404 errors on certain article pages. I pasted the error, described the behavior, and asked Cursor to diagnose. It identified the issue (a dynamic route parameter conflict), explained why it was happening, and fixed it in 3 minutes.
Without Cursor, I would have spent hours googling error messages, reading Stack Overflow answers from 2018, and trying solutions until something worked. Cursor understood my specific codebase and gave me a targeted fix.
Test 4: Adding a New Feature Under Pressure
A client needed a specific feature added to a web project within 24 hours. The feature: an interactive image gallery with filtering, lazy loading, and responsive grid layout. I described it to Cursor and it generated the entire component, including the CSS, the filtering logic, and the lazy loading implementation.
From request to working feature: 2 hours. From request to polished, production-ready feature: 4 hours (including my manual refinements). Without Cursor: this would have been a "sorry, I can't do it in 24 hours" conversation.
What Works
- Speed of iteration: I can describe what I want in plain English and get working code. Not pseudocode. Not "almost working" code. Working code that I can deploy. The iteration cycle — describe, generate, review, refine — is dramatically faster than manual coding.
- Learning accelerator: I'm not a programmer by training. I'm a filmmaker who learned to code out of necessity. I've learned more about how web development actually works in one month with Cursor than in years of trying to teach myself. It explains what it's doing while it does it. Every code generation is a mini-lesson.
- Refactoring without fear: Old code, messy code, someone-else's code — Cursor handles it all. The anxiety of touching legacy systems is gone because Cursor can explain what the code does, identify risks, and make changes surgically.
- Context awareness: Unlike generic AI chatbots, Cursor understands your project. It knows your file structure, your component patterns, your variable naming conventions. This means its suggestions actually fit your codebase instead of being generic examples you need to adapt.
- Agent mode for complex tasks: The ability to say "add dark mode to the entire site" and have Cursor modify 15 files consistently is remarkable. It plans the changes, executes them, and shows you everything before you accept.
What Doesn't Work
- Complex architecture decisions: For big-picture planning — should I use Next.js or Remix? How should I structure my database? What's the right caching strategy? — you still need a human who understands the tradeoffs. Cursor is brilliant at executing a vision. Terrible at creating one.
- Debugging its own errors: Here's the irony: when Cursor creates bugs, they're often harder to fix than bugs I'd create myself. Because the logic is more complex and the AI doesn't always explain its reasoning. I've had situations where Cursor's fix for a Cursor-created bug introduced a third bug. The cycle can be frustrating.
- Security awareness: Cursor writes functional code, not secure code. It won't automatically add input validation, CSRF protection, or proper authentication patterns unless you specifically ask. For anything that handles user data, you need security expertise that Cursor doesn't provide.
- Hallucination in APIs: Cursor sometimes invents API methods that don't exist. It will confidently use a function name that sounds right but isn't real, leading to errors that are confusing until you realize the AI made it up.
- Over-engineering: When given a simple task, Cursor sometimes produces overly complex solutions. Ask for a toggle button and you might get a state management system. You need to know enough about code to recognize when the solution is bigger than the problem.
Pros and Cons
Pros
- Dramatically faster development for standard web projects
- Excellent learning tool for non-developers building web projects
- Codebase-aware suggestions that actually fit your project
- Agent mode handles multi-file changes coherently
- $20/month replaces thousands in development costs for simple projects
Cons
- Creates bugs that are harder to diagnose than human-created bugs
- No architectural judgment — you need to make the big decisions
- Security is not handled automatically
- Occasional API hallucinations that waste debugging time
- Tendency to over-engineer simple features
- Code is sent to AI servers — consider NDAs and sensitive projects
Who It's For
Non-developer creators: If you're a filmmaker, designer, writer, or creator who needs web development capabilities but isn't a trained programmer, Cursor is transformative. It bridges the gap between having a vision and having a website. This is my use case, and it's where Cursor delivers the most value.
Solo founders: Building an MVP without a development team? Cursor lets you go from idea to functional prototype in days instead of weeks. The savings in development costs alone justify the subscription many times over.
Junior developers: Cursor accelerates learning and handles the boilerplate so you can focus on understanding patterns and architecture. It's like having a senior developer sitting next to you.
Experienced developers: For boilerplate, refactoring, documentation, and repetitive patterns, Cursor saves real time. It won't replace your architectural thinking, but it will free you to focus on it.
Not ideal for: Security-critical applications, projects under strict NDAs where sending code to AI servers is a concern, or teams that need their own proprietary development tooling.
The Verdict
Cursor isn't replacing developers. It's replacing the parts of development that developers hate: boilerplate, repetitive patterns, documentation, basic CRUD operations, and the hours spent googling how to do something you've done differently 50 times before.
What it can't replace: creative problem-solving, architectural decisions, understanding what users actually need, security expertise, and the judgment to know when code is "right" versus merely "working."
For me — a filmmaker who also builds web products — Cursor has been the single most impactful tool I've adopted. It turned me from "someone who struggles with code" into "someone who builds functional web applications." That's not incremental improvement. That's a category change.
Rating: 8/10 — Essential for modern development, especially for non-developers building web projects. Loses points for debugging its own errors, security blind spots, and the occasional hallucination. But the productivity gain is undeniable.