Yeah, everybody saw this coming. The tech Twitter prophecies, the LinkedIn hot takes, the “designers are cooked” posts that made the rounds every few months since 2024. Finally, it’s actually here. And here’s the thing nobody warned me about: it doesn’t arrive like an earthquake. It arrives like a Tuesday. One sprint you’re doing 50 screens for a checkout flow. The next sprint, a dev pastes your Figma link into Claude Code and has a working prototype before your standup’s even over.
So here’s what I actually did. I transformed — but not in the inspirational-quote way. I made a bare negotiation. I walked into a room and said: if you don’t need the Figma file, then let me know. Because I’m not going to grind my ass out getting 50+ pixel-perfect screens ready for your next sprint if the output gets thrown away anyway. I negotiated. And it worked.
I’m now, officially unofficially, the “vibecode director” at my org. Nobody gave me that title. I gave it to myself, mostly because somebody had to name what I was already doing. My job now is making sure the devs have everything they need to vibecode well. That’s it. That’s the whole job description. Well — yeah, and that’s a much bigger job than it sounds like.
So first things first — how did we get here?
This isn’t some abstract AI story. It has an actual origin date. Andrej Karpathy coined “vibe coding” in a viral post in February 2025 — the idea of fully giving in to the vibes, forgetting the code even exists, and letting the model handle implementation while you handle intent. Cute concept at the time. Kind of a shitpost, honestly. By 2026, it’s a hiring category. There are job boards with thousands of listings under “vibe coding” specifically, median pay in the six figures, posting growth that outpaces the original ML-engineer boom.
And the tool everyone points to for the design side of this shift is Figma itself, which — and I want you to sit with this — basically admitted the handoff model is dying. At Config 2026, Figma shipped “Code Layers”, which lets code live directly on the design canvas. No more “here’s the frame, good luck.” Repos get cloned right into the file. The stated goal is collapsing the handoff step that’s defined design-to-dev work for over a decade. That’s not a minor feature ship. That’s a company building defensive walls around a thing they know is eroding.
”But designers still need to design the thing, right?”
Yes. I agree. You might argue that vision, taste, and craft still matter — and let’s for the sake of this conversation agree that indeed they do. Somebody still has to decide what “good” looks like. But here’s the part that stings a little: the model can now generate a coherent, on-brand, working prototype from a paragraph of intent. Tools built specifically for this let developers skip the frame-to-code conversion entirely, grabbing a live component and outputting production React instead of a static screenshot you still have to rebuild by hand.
So the craft matters. But the 50-screen sprint deliverable? That part is dead weight now. Nobody needs me to draw every state of every button anymore. They need me to tell the AI — and the dev sitting next to the AI — what “good” even means before either of them starts generating.
So it’s back to paper wireframes then?
That’s the question everyone asks once the Figma file disappears — if the polished deliverable is gone, it must mean we’ve gone backwards, right? Rougher, less considered, back to napkin sketches and hoping for the best.
No. It’s not “less design.” It’s design moved to a different layer — and honestly, a smaller layer than I first thought.
Here’s what I mean. When I first made this shift, I figured my job was building the atoms by hand. Color, type, spacing, component states, the rules for how things behave — I write those, Claude Code runs in the project folder, the dev does what they please with it. That’s still roughly true. But here’s the part I got wrong at first: even the atoms aren’t really the repetitive grind anymore. Once Claude Code has access to the actual components, the variables, the primitives sitting in the codebase, it can put a lot of that together itself. Design systems, tokens, component libraries — that used to eat weeks. Now it’s not where the time goes.
So what does vibecoding actually solve, if not “designer builds tokens, AI builds screens”? It solves the repetitive part, full stop. Not just the screens — the systems underneath the screens too. Which means the meat of the job, the part that’s left over once you strip out everything repetitive, is smaller and weirder than “design system architect.” It’s sync.
The hard part was never the building. It was the syncing.
Getting Claude Code to actually work the way your team works — that was the hard part, and it stayed hard for a while. AI has a mind of its own. Left alone it’ll happily invent a fourth empty state, a slightly-off blue, a button that behaves differently on two screens, because nothing told it not to. Getting it in sync with how your team actually operates felt exactly like training an intern to follow company standards. You don’t do it once. You correct it, you write the standard down properly because you clearly didn’t the first time, you correct it again, and eventually it stops improvising in the wrong direction. Same exact process, except the intern never gets tired and never takes it personally when you redline the same mistake twice.
That’s the actual job now. Not drawing frames. Not even building the token set from scratch every time. Making sure the standards are written down clearly enough, and enforced consistently enough, that the model stops needing correction.
Wait, so are you an engineer now?
People ask me this a lot once I explain the setup. No. I’m not an ex-engineer, and I’m not becoming one. What I’m actually doing is using less and less Figma, on purpose, every month, because Figma is fast becoming a product designer’s problem in 2026, not their solution. Every cycle, there’s one more thing I used to do in Figma that now just happens in the project folder instead — a state, a variant, a whole flow. And I don’t think that trend reverses. There might genuinely come a point where I stop opening Figma altogether.
That’s not the same as “designer becomes engineer.” I still don’t write application logic, I still don’t own the codebase, I still think in hierarchy and flow and what the user’s eye does first — that part hasn’t moved an inch. What moved is the tool. The craft stayed. The canvas is the thing quietly going extinct.
What “vibecode director” actually means, day to day
Not glamorous. Let me be honest about it instead of turning this into a LinkedIn brag post.
Most of my day is now spent doing things that used to be invisible grunt work I did for myself, except now I do them for the whole team. I write the design tokens and interaction rules down properly, because if they’re vague, the AI output is vague too — garbage in, garbage out, except the garbage now ships in an afternoon instead of getting caught in review. I sit with devs while they prompt, not to write the prompt for them, but because the actual bottleneck in vibe coding isn’t generation anymore, it’s verification — someone has to look at the output and know, fast, whether it’s actually right or just looks right. That someone is often me, because I’ve spent a decade knowing what “right” looks like at a glance.
I also kill bad requests early now. A dev wants a settings screen “like Notion but cleaner” — cool, that’s not a spec, that’s a vibe, and vibes without constraints produce slop. My job is turning the vibe into the two or three decisions that actually matter (hierarchy, density, one clear primary action) before anyone opens a terminal.
The part that went badly
I won’t pretend this transition was smooth. It wasn’t. The first month, I lost real influence — I stopped being in the room for the “how should this actually work” conversations because everyone assumed the AI + a dev could just figure it out. A few flows shipped that were, frankly, incoherent — three different empty states, no consistent error pattern, because nobody with taste looked at it before it went out. I had to fight to get back into that loop, and not everyone was thrilled to have a designer showing up asking “wait, why does this button do two different things on two different screens.”
And some of my Figma craft — stuff I was genuinely proud of, component libraries I’d spent months building — just… stopped mattering as much. That’s a weird grief to sit with. Nobody prepares you for mourning a skill that’s still technically useful, just less central.
Where this leaves the rest of us
Here’s the honest read: this isn’t designers getting replaced. It’s the job getting re-centered. The industry’s even got a name for it now — some are calling it the shift from UX Designer to UX Engineer, where the people who thrive aren’t the ones producing the most beautiful frames, but the ones who understand structure, systems, and what happens after the frame gets handed off — or doesn’t get handed off at all.
I didn’t ask for this shift. I don’t think anyone in this field actually wanted it to happen this fast. But I did the one thing that actually helped: I stopped pretending the 50-screen deliverable still made sense, and I named the new job before someone named it badly for me.
If you’re staring down the same thing right now — negotiate. Don’t wait for someone to hand you a new title. Nobody’s coming to write your job description for you anymore. You’ve got to vibe-code your own role, too.