The Dev Workflow is Broken. Vibe Coding Fixes the Right Parts.
What actually changes — and what doesn’t — when AI enters every stage of your development process
Most developers treat vibe coding as a replacement for disciplined software development. It isn’t. It’s a remix of it. And if you don’t understand the original before you remix it, you’re going to ship something fragile — just faster than before.
This edition was adapted from Vibe Coding with Cursor, Windsurf, and Lovable by Greg Lim.
In this post
Why the SDLC still matters in an AI-assisted workflow
Planning: the stage AI can’t replace
Design: the decisions that still belong to you
Implementation: where AI actually earns its keep
Testing: the part most vibe coders skip
Deployment and maintenance: what changes, what doesn’t
How to pick a tech stack when AI lowers every barrier
Why the SDLC still matters in an AI-assisted workflow
The software development lifecycle has six stages. Planning, design, implementation, testing, deployment, maintenance. You know them.
For decades, the bottleneck was implementation. Writing the code was the slow, expensive part. Everything else — planning, design, testing — existed to protect the code from going wrong.
Now that AI can write code faster than most engineers, the bottleneck has shifted. But the stages haven’t disappeared. What’s changed is where the leverage is — and where the new failure modes are hiding.
Here’s what that looks like across each stage.
Planning: the stage AI can’t replace
This one doesn’t change much. And that’s the point.
Before AI, bad planning led to slow, expensive rewrites. With AI, bad planning leads to fast, cheap, wrong builds that still need expensive rewrites.
The speed of AI implementation doesn’t make upfront planning less valuable. It makes it more valuable. You can now spiral into the wrong thing at 10x the velocity.
What good vibe coding looks like here: use an LLM as a consultation partner before you write a single prompt to your IDE. Ask it to poke holes in your idea. Ask it what you haven’t considered. Treat it like a senior engineer in the room — not a code dispenser.
The planning stage is where you go from idea to requirements. Who is this for? What do they need? What does the project actually involve, scoped into concrete tasks? Don’t underestimate it. It’s the foundation for everything that follows.
Design: the decisions that still belong to you
Architecture decisions still belong to you.
Which tech stack? How does the data model look? What APIs are you relying on? Where do you draw the service boundaries? What does the UI flow look like?
AI will happily make all of these decisions for you if you let it. And it’ll make them confidently — and incorrectly for your specific context.
The vibe coding trap here is mistaking speed for correctness. A poorly architected app built in 30 minutes is still a poorly architected app. The AI didn’t know about your team’s constraints, your infra costs, or the edge cases in your domain. You do.
The practical move: bring your architecture questions to an LLM before you open your AI IDE. Use it to stress-test decisions, not make them. Your codebase will thank you six weeks from now.
Implementation: where AI actually earns its keep
This is where AI earns its keep. Seriously.
Code generation has gotten genuinely good. If you have a clear specification and a well-scoped task, a tool like Cursor or Windsurf can implement entire features in the time it would take you to write the function signature.
Two things still matter though.
One: the specification has to exist first. Zero-shot prompts (”build me a Kanban board”) produce zero-shot quality. The AI isn’t bad. The instruction was bad. Invest time upfront in a proper spec document — what the app should look like, how it should behave, what technologies to use. Then break it into a phased TODO list and work incrementally. One feature at a time.
Two: you still have to read the code. AI is non-deterministic. The same prompt produces different outputs on different runs. Treating generated code as ground truth without reviewing it is how bugs get shipped quietly — and in an AI-assisted codebase, the blast radius of a broken change is larger because the AI has touched every file.
Testing: the part most vibe coders skip
Don’t skip it.
Automated tests aren’t bureaucracy. They’re the thing that lets you keep moving fast after the first 20% of the build. Every feature you add without a corresponding test is debt you’ll pay in debugging time later.
The good news: AI is useful for writing tests too. Ask your tool of choice to write end-to-end tests for every feature you complete. Make it a rule, not an afterthought.
Some tools can be configured to run tests automatically after every change so you never have to remember to ask. In Cursor, for example, you can set a project rule — “after making changes to the codebase, run all tests to ensure they pass” — and it’ll happen without you prompting it each time. That’s not a nice-to-have. That’s how you stay confident as the codebase grows.
The types worth knowing: unit tests cover individual functions, integration tests check how components work together, and end-to-end tests simulate real user interactions. An AI-assisted project should have all three. If you’re building fast, start with E2E tests for your critical paths.
Deployment and maintenance: what changes, what doesn’t
Deployment
The pipeline hasn’t changed structurally. Staging environments, version control, production releases — the process is the same.
What’s changed: AI can now walk you through the entire deployment process conversationally, including catching build errors and suggesting fixes in real time. The friction that used to live here — figuring out how to configure Vercel, what the build flags need to be, what the CI error means — is largely gone. It’s now a conversation, not a documentation spelunk.
Maintenance and iteration
This is the stage that breaks most AI-assisted projects.
Bug reports come in. Features need updating. Dependencies get flagged. And now you’re back in the codebase — except you didn’t write most of it.
The engineers who do this well are the ones who maintained a specification document throughout the build. They kept their TODO list updated. They reviewed every line the AI generated. They committed frequently to version control so rolling back to a working state is one prompt away.
Vibe coding done right is still disciplined coding. The discipline just lives in different places now — in the spec, the commit history, the test suite, the rules file. Move those things and the maintenance phase becomes painful regardless of how fast the build went.
How to pick a tech stack when AI lowers every barrier
Pick the stack you know, not the stack that’s trending.
This sounds obvious. It isn’t practiced.
AI tools are seductive here. They’ll happily scaffold a project in any language or framework you name. That doesn’t mean you should reach for a new stack just because the barrier to entry is lower now.
The engineers who ship fastest with AI-assisted tools are the ones using stacks they already understand. They can catch the AI’s mistakes. They know what “correct” looks like. They can debug when the AI confidently produces something broken.
If you’re a JavaScript/TypeScript person, stay there. Full-stack with React on the frontend and Node on the backend is still one of the most productive setups for AI-assisted development — one language end-to-end, massive community, tons of tooling. If you’re a Python person, your backend instincts plus AI assistance is a strong combination, and Python’s dominance in AI/ML means the ecosystem keeps getting better.
New stack, new language, AI-assisted build, tight deadline — that’s four variables you don’t want active at the same time.
The one-line summary
Vibe coding shifts the bottleneck from writing code to thinking clearly about what to build.
The SDLC isn’t a relic. It’s the foundation that makes AI-assisted development actually work. Skip the stages you think AI has replaced and you’ll find out exactly why they existed.
This edition was adapted from Vibe Coding with Cursor, Windsurf, and Lovable by Greg Lim.
The full book covers every stage hands-on — building a Math Practice app with Cursor, a Kanban board with Lovable, and working on existing codebases with Windsurf.
Get the book. On us.
We’re giving away a free copy of Vibe Coding with Cursor, Windsurf, and Lovable by Greg Lim to every new subscriber of BuildWithAI.
Subscribe below and we’ll send it your way.