Yesterday, during a company review meeting, we got our first look at a feature built internally using vibe coding. Silence. Developers gasping.
If you've been following along, you know I have complicated feelings about this. I can't stand half-baked apps thrown together by people with no foundational knowledge, dressed up as professional products and shipped to real users. At the same time, I genuinely think vibe coding is a fantastic tool when used with intention, particularly for prototyping.
And this was more like it.
The feature in question was a simple task list that needed redesigning. Instead of building out the design in Figma and handing it off, one of the product designers decided to pick up Cursor. She prompted it to create a new version, styled things as intended, and delivered a prototype that was not just visual. It was functional.
From there, engineers stepped in. They reviewed the structure, checked that the AI's decisions aligned with existing standards, and validated the work before it went anywhere near production. But their involvement had actually started earlier, during the prototyping phase itself. Teaching prompt engineering, flagging architectural pitfalls, coordinating how the feature should evolve. The developer contribution wasn't a final stamp of approval. It was woven throughout.
The result is a real improvement. Cleaner, less clunky than the previous version, delivered significantly faster than a traditional design-then-develop cycle. And it created something I didn't expect: a tighter collaboration between designer and developer. They solved a problem together, using a different set of skills, instead of producing separate artifacts and passing them back and forth.
A few things worth naming honestly. This feature was low in architectural complexity, mostly a visual rework of something already working underneath. The team involved is heavily backend-focused, which made the designer bridging that gap both practical and necessary. And the engineers' role throughout was not incidental. Without it, this wouldn't have been production-ready.
Still, coming from a frontend background, this is unsettling to sit with.
And yet I can't bring myself to dig in stubbornly against it. Developers have always built abstractions over their own work to reduce friction. Assembly to high-level languages. Frameworks over raw code. Open source packages over building from scratch. Every generation of tools took something that required deep manual effort and made it more accessible. This is the same pattern, just more dramatic, and more powerful.
We're moving toward building with natural language. That's a real shift. But architectural knowledge, systems thinking, understanding patterns — these still matter. They're what lets you evaluate what the model produces, tighten the feedback loop, and steer the output toward something that actually makes sense. The background knowledge doesn't disappear in value; it changes in how it gets applied.
Will that always be true? I'm not sure. Models might eventually become capable enough that the human-in-the-loop becomes optional. But I still believe that building meaningful products isn't purely mechanical. There's a human dimension to it — in deciding what to build, why it matters, how it should feel - that I don't think models will dissolve anytime soon.
Our role is changing, not ending. Knowing every syntax detail of every language matters less. Understanding what you're trying to achieve, and why, matters more. Good practices can be taught to models to some extent — but there will always be a layer where human judgment makes the difference.
We're less developers, more engineers. It's a progression we built ourselves. And now it's impossible to stop.