from 'this is impossible' to 'holy sh*t it works!'
A Data Analyst's Journey from SQL Queries to Full-Stack Development with AI
I stared at my screen at 2 AM, watching Cursor rewrite my entire Flask application structure. Three weeks earlier, I'd sworn I'd never again touch a no-code app builder after burning myself out on a Bubble.io project.
My background as a data analyst had me dwelling too much on the backend stuff, mainly using SQL and Python for my job. I had to start dipping my toes into JavaScript and eventually HTMX to be able to achieve what I wanted: developing a full-stack application.
Yet here I was, three weeks into rebuilding my entire SaaS from scratch.
The Python part felt familiar—I could write queries and manipulate data all day.
But frontend? That was foreign territory. HTMX promised to be the bridge I needed, letting me stay mostly in Python while building dynamic interfaces.
The moment that shifted everything happened when Cursor's agent casually restructured my entire codebase. I'd typed a throwaway comment: "This feels messy, can you help organize it better?" Twenty seconds later, it had created a proper MVC pattern, moved my database queries into service layers, and fixed three bugs I didn't even know existed.
And...it actually worked.
The Project That Started Everything
Let me back up. I'd built JobCopy on Bubble—a resume builder that helped job seekers with AI-powered content generation. It worked, sort of. But as I added features, the no-code platform started fighting me. Every new integration felt like performing surgery with oven mitts on. The project became a tangled mess of workflows and database relationships that made my eyes bleed.
So I decided to rebuild it properly. JobTurbo would be everything JobCopy wanted to be: a complete job-seeking platform with resume building, cover letter generation, and intelligent job matching using AI.
My first instinct was to use WeWeb. I'd already built a sales tool there (Luma.AI—don't look for it, it's dead). But something made me pause. I kept seeing Cursor AI mentioned in my LinkedIn feed. So I decided to check it out first.
Lessons Learned the Hard Way
1. Start with a Mega Prompt (Or Watch Your Money Burn)
My first attempt with Cursor was embarrassing. I typed: "Build me a resume builder app in Python using Flask. Build an interactive IDE where users can make edits to the resulting resume."
Cursor dutifully generated 500 lines of code that did... nothing. I spent 2 hours in back-and-forth messages to just get the “python app.py” command running fine.
Here's what actually worked: I created a comprehensive prompt that included:
Complete tech stack (Flask, HTMX, Tailwind, Supabase)
Database schema and relationships
API integrations needed
User flow from sign-up to PDF export
Folder structure preferences
When I fed Cursor this 500-word prompt, magic happened. It didn't just write code—it created an entire project architecture that actually made sense.
The lesson? Treat your first prompt like a blueprint.
The more specific you are upfront, the less time you'll waste untangling AI-generated spaghetti later.
I uploaded it and shared it just in case you need it for free.
2. The Agent Mode is Your Senior Developer
Discovering Cursor's agent mode was definitely a “WOW” moment. Instead of asking for specific code changes, I could describe problems and let Cursor figure out the solution.
"The resume generation is too slow when users upload large CSV files with their work history."
Cursor's agent went to work. It analyzed my code, identified that I was processing everything synchronously, and rewrote the entire flow using Celery for background tasks. It even added a progress bar and websocket updates.
3. You Can Lose Control Faster Than You Think
One time, I asked Cursor to "improve the user authentication flow visually." It made a couple of changes and finished in less than 10 iterations. In reality, this is everything it did:
Replaced my simple session-based auth with JWT tokens
Added a "remember me" checkbox that created refresh tokens
Implemented password reset emails (without asking which email service I used)
Created a new 'users_sessions' table to track active sessions
Cool? Sort of. What I asked for? Not really. I just wanted the login form to look better.
And that’s a con of the agent mode: sometimes it just doesn’t follow instructions.
I spent the next couple of hours debugging an authentication system I didn't write and barely understood.
This is the trap: Cursor makes you feel like a 10x developer, but you're really just a very fast 0.1x developer if you don't understand what's being built.
4. API Costs Will Slap You in the Face
Let's talk money:
Week 1: $12 (honeymoon phase)
Week 2: $67 (getting serious)
Week 3: $183 (full addiction)
Week 4: $340.17 (Chapter 11 bankruptcy)
Each thoughtful refactoring conversation with Claude Sonnet?
That's $2-3, easy.
Track your costs daily or prepare for sticker shock.
5. Read Every Line (Or Lose Control of the Codebase)
The scariest moment came during maintenance downtime. I needed to fix a simple bug and spent 10 minutes trying to remember how to write a for loop. In Python. A language I'd been "coding" in for almost 5 years.
Cursor had turned me into a director instead of a developer.
I was great at describing what I wanted but couldn't build it myself. The fix? I started treating every Cursor generation as a learning opportunity. Read the code. Google the patterns.
Understand the why, not just the what.
6. Documentation Context is a Superpower
The @docs feature changed everything. Point Cursor at any library's documentation, and it becomes an instant expert. No more tab-switching between docs and code.
When I discovered this, my productivity doubled overnight.
I was in “copy-docs-then-paste-them-into-chat” mode until I found out about this amazing feature.
But here's the catch: you need to know which docs to feed it. Cursor can't read your mind about which libraries might solve your problem.
You still need to be the architect.
7. MCP Support Made Me Lazy (In a Good Way)
When Cursor added Model Context Protocol support, connecting to Supabase became a single command instead of a multi-file integration dance.
This felt like cheating, but it's the good kind of cheating that lets you focus on building features instead of boilerplate.
8. Know When to Pull Back
The hardest lesson: sometimes Cursor's suggestions are too clever.
When it wanted to add Redis caching for my 10-user beta, I had to say no.
When it suggested microservices for a monolith that worked fine, I said no again.
AI amplifies your decisions—both good and bad.
If you don't have opinions about your architecture, Cursor will give you every bell and whistle whether you need them or not.
The Verdict
JobTurbo launched after two months. Users could upload CSVs, connect LinkedIn, and get AI-powered resumes in minutes. It worked. Was it perfect? No. Did 50 other resume builders launch the same month? Yes.
But I shipped. I built something real that actual people used. And I learned more about software development in two months than I had in the previous two years of no-code building.
Cursor AI isn't magic. It's a power tool that can either build you a house or saw off your thumb, depending on how you hold it.
Use it wisely, and you'll build things you never thought possible.
Use it carelessly, and you'll have a very expensive mess.
The impossible became possible. Even if I whispered "holy shit" the entire time.
P.S. - Start small. Build a CLI tool first. Your future self (and wallet) will thank you.