New kids on the block
These tools are not “better IDEs”.
They’re a new workflow.
Old workflow: you think, you write, you run, you fix, you repeat.
New workflow: you describe intent, the tool drafts code, you steer, you verify, you repeat.
That shift matters for Product Managers, because it changes what “hands-on” looks like. You don’t need to ship production systems. You need to explore ideas quickly, reduce dependency on favours, and learn faster than your calendar allows.
Cursor, Windsurf, Lovable and Bolt are part of that shift.
Not magic. Not a shortcut to engineering mastery.
A lever.
What even is “vibe coding”?
Vibe coding is not a technical term. It’s a behaviour.
It’s the moment you stop writing every line yourself and start working like a director:
describe the outcome
constrain the style and structure
review the draft
correct the mistakes
run it again
The “vibes” part is real. These tools reduce friction. They make iteration feel light. You move faster, and you’re more likely to keep going.
That’s useful.
It’s also dangerous, because speed can hide quality problems until the last minute.
Cursor
Cursor is the most “serious” of the bunch. It feels like a code editor first, with AI woven through the workflow.
If GitHub Copilot is autocomplete, Cursor is closer to “pairing with an AI that can see your repo”.
What it’s good for
understanding unfamiliar code fast
refactoring without breaking everything
small feature spikes and prototypes
reviewing pull requests with more confidence
quick data wrangling scripts that you can throw away later
Why it works
Cursor lets you highlight code and ask targeted questions. You’re not prompting into a void. You’re prompting against the actual files.
That matters when you’re a PM trying to avoid cargo-cult code.
What to watch
it will confidently change things you didn’t ask it to change
long sessions drift without strong constraints
big files and messy repos amplify hallucinations
you still need a plan, especially for anything cross-cutting
If you use Cursor, treat it like a fast junior dev. Helpful. Not authoritative.
Try it: https://www.cursor.com/
Lovable
Lovable is for turning an idea into a working web app without spending your week wiring the basics.
It’s strongest when you want:
a prototype that looks like a real product
a basic full-stack flow (UI + auth + database)
something you can show, test, and iterate on quickly
It shines in “PM mode”:
internal tools
MVPs
clickable flows with real data
pitch-ready demos that don’t look like Figma
What it’s good for
fast scaffolding with modern defaults
getting to a live preview quickly
connecting to services like Supabase without the usual setup pain
What to watch
it gets brittle when you go off the happy path
repeated edits can introduce weird UI inconsistencies
you can end up fighting generated structure instead of building value
it’s easy to overbuild because it feels so easy to add “one more thing”
Lovable is best when you keep scope tight and treat the code as disposable until proven otherwise.
Try it: https://lovable.dev/
Bolt
Bolt is the fastest route from idea to something running in a browser tab.
That’s the whole product.
No setup. No local environment. No “it works on my machine”.
What it’s good for
early proof-of-concepts
hacky experiments
UI spikes
“can we even do this?” demos
Bolt is brilliant when you want momentum, not architecture.
What to watch
credits can disappear fast if you iterate wildly
changes can overwrite things in ways that feel chaotic
it’s not designed for careful collaboration or long-term code health
you still need version control somewhere else if it matters
Bolt is a sketchpad. Treat it like one.
Try it: https://bolt.new/
Windsurf
Windsurf is the calm one.
It’s optimised for flow: fewer distractions, cleaner UX, less “panel soup”.
If you find most AI coding tools noisy, Windsurf will feel like relief.
What it’s good for
staying in context without constantly switching modes
editing specific lines with precision
drafting and refining code in smaller steps
debugging loops that include terminal actions
What to watch
product maturity varies by feature
pricing and plan limits can be a factor
it can struggle on complex, multi-module repos
some of the “agentic” features need careful supervision
Windsurf works best when you prefer steady progress over maximum speed.
Try it: https://windsurf.com/
Why these tools work for Product Managers
Because they reduce the cost of curiosity.
You can:
test a small hypothesis without booking engineering time
build a prototype that answers a specific question
inspect code enough to ask better questions in review
create working artefacts for stakeholder alignment
learn by doing, in short loops, without a perfect setup
This is the real unlock: better iteration loops.
Not “PM becomes engineer”.
PM becomes faster at discovery, sharper in trade-offs, and more credible in delivery conversations.
The warning: vibes are not validation
AI can generate code that:
runs, but is insecure
works, but is unmaintainable
looks correct, but fails on edge cases
passes the demo, but breaks under load
So use a simple rule:
Prototype with AI. Validate with discipline.
If it’s heading anywhere near production:
get an engineer to review it
add tests for the important paths
run a basic security sanity check
document assumptions and constraints
delete and rebuild if the foundations are wrong
Speed is only valuable if it doesn’t create hidden debt.
Final thoughts
This wave of tools changes what “shipping” can look like for Product Managers.
You can move from abstract discussion to working artefact faster.
You can turn vague ideas into specific trade-offs faster.
You can learn the shape of a solution before you ask a team to build it.
One implication for builders: the competitive edge isn’t the tool you pick. It’s whether you build a repeatable loop around it.
Small prompt. Small prototype. Real feedback. Clear decision.