We prompt-engineered ourselves into a corner. Now the market wants engineers again not prompt jockeys.
You ever ship a product nobody wanted?
Same. Specifically, a SaaS tool. I built it in a weekend. Cursor wrote 90% of it. It had a landing page, a pricing table, a waitlist. Looked genuinely good. Felt like cheating.
Nobody signed up.
Not because the idea was bad. Because the idea was everywhere. By the time I shipped, there were already six nearly identical tools on Product Hunt. Same gradient blob header. Same “seamless, effortless automation” hero copy. Same three-tier pricing. Same vibe.
That’s the thing about vibe coding it worked too well.
In early 2024, Andrej Karpathy dropped the term and basically handed every developer, designer, PM, and guy-with-a-napkin-idea a skeleton key to software. “Fully give in to the vibes,” he said. “Forget that the code even exists.” And we did. God, we did. Cursor blew up. Bolt.new launched. Replit got a second wind. A whole generation of builders who’d never touched a terminal shipped real products in real weekends. It was electric.
Then everyone got the cheat code at the same time.
The internet didn’t get richer. It got noisier. Identical tools. Identical copy. Identical forgettable experiences that bounce users in four seconds because they’ve already seen this page twice today. What started as a unlock became a commodity. And commodities don’t make money.
So here we are. The vibe is fading. Not because AI got worse. Because everyone has it now and “everyone can build” turns out to mean “nothing you build automatically stands out.”
This piece is about what actually killed vibe coding, what the market quietly started asking for instead, and what kind of engineer actually wins in 2026. Not hype. Just pattern recognition from watching a lot of weekend SaaS tools die in silence.
Here’s what we’re covering:
- The vibe coding era and how it ate itself
- The slop problem when everyone builds, nothing stands out
- Why the market is quietly pivoting back to real engineers
- The new skill stack that actually matters now
- What comes after the vibes
The vibe coding era and how it ate itself
Let’s be fair to vibe coding for a second. Because before we bury it, it deserves a real eulogy.
What Karpathy described wasn’t laziness. It was a genuine unlock. For the first time, the bottleneck between having an idea and shipping an idea basically disappeared. You didn’t need to know React. You didn’t need to understand why your CSS was broken. You just described what you wanted, iterated in natural language, and something real came out the other side. Designers started shipping backends. PMs started prototyping their own feature requests. Solo founders stopped waiting on dev agencies and just built the thing themselves.
That was real. That mattered. Vibe coding democratized building the same way smartphones democratized photography.
And then same as smartphones everyone became a photographer.
The problem with cheat codes is they stop being cheat codes the moment everyone has them. In 2024, shipping a functional web app in a weekend felt like a superpower. By mid-2025, it was table stakes. By the time you’re reading this, it’s basically the minimum bar for a side project. The speed advantage compressed to zero. What took a 10x engineer two weeks now takes a prompt-comfortable beginner two days. Great for the beginner. Rough for differentiation.
“When everybody can build without effort, the value of building also decreases.”
That line is from Michal Malewicz’s piece and it’s the cleanest way to say it. The floor rose. But so did the noise.
Think about what actually happened on Product Hunt over the last eighteen months. A tidal wave of GPT wrappers. AI summarizers for every possible document format. “Notion but with AI.” “Slack but with AI.” “Email but with AI.” Each one functional. Each one shipped fast. Each one forgotten in a week. The Hacker News graveyard of vibe-coded microsaas is long and it keeps growing.
I remember the exact moment it clicked for me. I was doing competitive research which, yes, just means googling your own idea to see who beat you and I found a tool that was basically what I was building. Fine, happens. Then I found another one. Then three more. Then I realized I was looking at the same Tailwind template with different color schemes and different domain names. Different founders. Same vibe. Same outcome: none of them had meaningful traction.
That’s the tragedy of the commons playing out in SaaS form. When the resource is “ability to build software quickly,” and everyone gets access to it simultaneously, the resource stops being scarce. And in markets, scarcity is where value lives.
Vibe coding didn’t fail because the tools got worse. It failed because it succeeded too completely.
The slop problem: when everyone builds, nothing stands out
There’s a word that’s been floating around developer Twitter for a while now and it finally stuck: slop.
Simon Willison coined it cleanly AI-generated content that’s technically correct, aesthetically acceptable, and completely, soul-crushingly generic. Not broken enough to reject. Not good enough to remember. It just exists. Takes up space. Occupies a URL.
We have a slop epidemic. And it’s not just content anymore it’s products.
Open any three AI tools launched in the last year. I’ll wait. Notice anything? Gradient blob in the hero. Sans-serif headline that says something about streamlining your workflow. Feature grid with checkmarks. Pricing table, three tiers, middle one highlighted. Testimonials section with suspiciously perfect five-star reviews from people named “Sarah, Marketing Manager.” A footer with a cookie banner that nobody reads.
You’ve seen this page. You’ve seen it forty times. Your brain pattern-matches it in about 1.3 seconds and files it under skip. Not because it’s bad. Because it’s identical. And identical things don’t convert. They don’t get remembered. They don’t get shared. They quietly die with eleven monthly active users, three of whom are the founder’s friends doing a favor.
This is what happens when the tool abstracts away not just the complexity of building but the craft of building.
Craft is the thing that used to slow people down and also the thing that made work distinct. When building something took weeks, you made decisions. You had opinions. You pushed back on bad ideas because you were the one who’d be living in that codebase for months. Vibe coding removed the friction. But friction, it turns out, was doing some useful filtering.
The users noticed before the builders did. Conversion rates on AI-generated microsaas have been quietly disappointing across the board. Not because users hate AI tools they use them constantly. But because they’ve developed a very fast radar for soulless products. They bounce. They churn. They don’t recommend. The attention economy isn’t getting fooled by a well-prompted landing page anymore.
What’s worse is the security layer nobody talks about. Vibe-coded apps often skip the boring parts input validation, auth edge cases, rate limiting, dependency hygiene. Not maliciously. Just because the vibe doesn’t naturally lead you there. AI autocomplete isn’t going to stop mid-generation and say “hey, should we think about SQL injection here?” OWASP has been quietly updating their guidance on AI-assisted development risks and the pattern is consistent: fast shipping without fundamentals creates exploitable surface area at scale.
The slop problem isn’t a design problem or a marketing problem. It’s a depth problem. You can’t vibe your way to a product that people trust, return to, and tell their colleagues about. That takes something the AI can accelerate but cannot replace: genuine understanding of what you’re building and why it should exist differently than the other 192 things exactly like it.
Why the market is quietly pivoting back to real engineers
Nobody’s going to announce this. There won’t be a TechCrunch headline that says “vibe coding era officially over, fundamentals back in fashion.” It’s happening the way most market corrections happen quietly, in hiring docs and Slack threads and post-mortems that never get published.
But it’s happening.
Talk to anyone doing technical hiring right now and you start hearing the same thing. The bar shifted. Not away from AI fluency that’s still table stakes but toward people who can actually reason about what the AI produces. Who can read a stack trace. Who can look at a 400-line function Cursor generated and say “this works but it’s going to fall over at scale and here’s why.” That person is suddenly very hard to find.
Because a lot of people spent the last eighteen months optimizing for speed of generation instead of depth of understanding.
“I can build anything.”
“Okay. Can you debug it?”
“…give me a sec, I’ll ask Claude.”
That conversation is happening in interviews right now. And it’s ending careers.
The dirty secret of vibe-coded codebases is what happens six months after launch. The MVP shipped fast. Users came in. Things broke in ways the AI didn’t anticipate because the AI was pattern-matching on training data, not reasoning about your specific architecture. Now you’ve got a production system, real users, and nobody on the team who actually understands what they built. The tech debt isn’t just messy it’s illegible. You can’t refactor what you can’t read.
Companies that moved fast on vibe coding are now quietly hiring people to clean up the aftermath. Not prompt engineers. Engineers. People who understand memory management, database indexing, API design, security boundaries. The boring stuff that never made it into the weekend build tutorial.
And here’s the thing that should make every developer feel something between vindicated and relieved: the GitHub research on Copilot showed a 55% productivity gain for developers using AI assistance. But that gain compounds on top of existing skill. A strong engineer with Cursor is terrifyingly productive. A weak engineer with Cursor is just a faster way to produce confused code nobody can maintain.
The multiplier needs a base number to multiply.
roadmap.sh never stopped being relevant. DSA never stopped mattering. System design never became optional. The market just temporarily forgot that because the demo always works. It’s production that filters signal from noise.
The devs who kept their fundamentals sharp while picking up AI tooling? They are the rarest, most in-demand creature in the current market. Not because they rejected the new tools. Because they never let the new tools replace the old thinking.
The new skill stack that actually matters now
Let me kill a bad take before it spreads further.
This is not “AI bad, go back to writing everything by hand.” Nobody’s asking you to ditch Cursor and suffer through boilerplate like it’s 2019. That’s not the point and anyone selling you that narrative is either scared of the tools or trying to sell you a course about being scared of the tools.
The point is simpler and slightly more uncomfortable: AI is a multiplier. Multipliers need a base stat.
If your base stat is zero, multiplying it by ten still gets you zero. Just faster. With a nicer landing page.
The engineers winning right now actually winning, not just shipping demos are running a specific combination. They have genuine fundamentals. They understand how systems talk to each other, where things break under load, why that database query is slow, what that error actually means two layers below where it surfaced. And on top of that, they use AI tooling the way a surgeon uses a good scalpel. Precisely. Intentionally. With full awareness of what they’re cutting.
“Vibe coding is a power tool. Power tools still require the user to know what they’re building.”
Figma is a useful comparison. When Figma launched, a certain category of designer panicked the ones whose value was mostly in knowing the software, not in the craft of design itself. The designers who understood visual hierarchy, typography, user psychology, interaction patterns? Figma made them faster. It didn’t replace them. It filtered them up.
Same thing is happening now. AI is the new Figma. It’s separating the people who understood the craft from the people who understood the process.
So what’s the actual stack? What should you be building or rebuilding right now?
Systems design still matters maybe more than ever, because AI will generate the components but you have to architect the thing they fit into. Debugging is now a superpower, not a chore because everyone can generate code but almost nobody can read the AI’s code and understand why it fails. Security fundamentals are non-negotiable because vibe coding skips them by default and someone has to care. And reading documentation actual docs, not the AI’s summary of the docs is back on the menu, because roadmap.sh and MDN and AWS docs contain things the model occasionally hallucinates away.
ThePrimeagen has been saying this for two years and getting called a doomer for it. He wasn’t being a doomer. He was just early.
The irony is that AI making everything easier has made genuine depth more valuable, not less. When the floor rises, the ceiling is the only place left to compete.
You don’t have to choose between AI fluency and engineering depth. The devs who framed it as a choice are the ones getting lapped right now. Pick both. Use the tools. Keep the brain running underneath them.
What comes after the vibes
Here’s the take I’ll probably get ratio’d for: vibe coding dying is the best thing that could’ve happened to software engineering.
Not because AI is bad. Not because fast shipping is bad. But because the signal-to-noise problem was getting genuinely unsustainable. When every weekend produces a thousand new tools that look identical, feel identical, and die identical the users stop trusting. The market stops caring. And the actual good ideas get buried under an avalanche of gradient blobs and three-tier pricing tables nobody asked for.
The correction was necessary. And it’s not over yet.
What comes next isn’t a return to the old world. Nobody’s going back to writing CSS floats by hand and feeling noble about it. The tools are here, they’re good, and they’re getting better. What’s shifting is the expectation layer sitting on top of the tools. The bar for “good enough to matter” just got raised permanently. Fast is no longer enough. Fast and real is the new minimum.
The developers who come out of this moment strongest are the ones who treated the last two years as a skill expansion, not a skill replacement. They learned the tools. They also kept the fundamentals alive. They can generate code and understand it. Ship fast and debug what breaks. Prototype in a weekend and architect for what happens after the weekend.
That’s not a rare archetype. It’s just a disciplined one.
“The vibe was never the enemy. Mistaking the vibe for the whole job was.”
I’ve watched enough dev cycles to know how this one ends. The hype fades. The dust settles. And what’s left standing is what was always left standing people who genuinely understand the thing they’re building, using whatever tools the current era provides to build it better and faster than they could before.
Vibe coding was a chapter. A genuinely exciting one. But the book isn’t about the vibe. It’s about what you actually ship, how it holds up, and whether anyone’s still using it six months later.
The era of building anything is over. The era of building something worth keeping is back.
Drop your take in the comments are you a vibe coder, a fundamentals dev, or somewhere in the middle trying to figure out which half of your brain to trust? I want to know where people are landing on this one.
Top comments (0)