TLDR: AI writes 60–80% of the code; you steer and review. The productivity gains are real — 2-day features in 2–4 hours. So are the risks — hallucinated APIs, security gaps, accessibility blind spots. The senior dev skill is shifting from writing fast to evaluating accurately.
Six months ago I described a feature in two sentences and watched Claude Code write the component, the typed service, the route, and the unit tests. It took about 90 seconds. The code was good enough that I kept 80% of it.
That's not a party trick. That's a workflow shift — and if you're still treating AI tools as fancy autocomplete, you're leaving a lot on the table.
The term was coined by Andrej Karpathy in early 2025: "fully give in to the vibes, embrace AI as a co-pilot, and forget that the code even exists." The last part is where I disagree with him — you absolutely cannot forget what the code does. But the rest of it is real.
What vibe coding actually is (it's a spectrum)
| Level | What it looks like |
|---|---|
| Autocomplete | Copilot filling in the next line |
| Chat-driven | Asking Claude to write a component |
| Scaffold mode | Describing a whole feature and iterating |
| Full vibe | Describing an app, reviewing diffs, barely writing code manually |
Most frontend devs I know live in scaffold mode — AI generates 60–80% of the code, you steer and review. That's where the productivity gains are real without the risk of shipping code you don't understand.
The tools that are actually worth your time
Claude Code — Anthropic's agentic CLI. It reads your entire codebase, writes files, runs commands, and iterates. I use it for complex multi-file refactors, adding new features with established patterns in the codebase, and anything that requires touching more than 3 files at once.
Cursor — VS Code fork with deep AI integration. Agent mode can plan and execute multi-step edits across files. The tight IDE integration makes the feedback loop faster than switching to a terminal tool. My go-to for single-feature work where I want to stay in the editor.
v0 by Vercel — Prompt → polished React/Tailwind UI in seconds. I use it to prototype components I then customize, not as a final output tool. It's shockingly good at getting you to 70% in 30 seconds.
Bolt — Full-stack scaffolding from a single prompt. Generates a running Next.js or SvelteKit app. Useful at the very beginning of a project when you want a skeleton to build on, less useful once you have opinions.
These tools are not editors. They're collaborators. The mental model shift matters — you're directing, not typing.
What a session actually looks like
1. Write a one-paragraph description of the feature
2. Let the AI scaffold the structure (components, types, service)
3. Read the diff — actually understand what was generated
4. Iterate via follow-up prompts ("make the loading state use a skeleton")
5. Run tests — fix what breaks
6. Review the final code as you would a junior dev's PR
The discipline is steps 3 and 6. You must read what you ship. Vibe coding doesn't remove engineering judgment — it relocates it from writing syntax to reviewing architecture. That's a better use of senior time.
What you actually gain
Speed: Features that took 2 days now take 2–4 hours. Not because the AI is smarter than you — because it handles all the boilerplate, type wiring, and API surface lookups that aren't interesting work anyway.
Exploration breadth: You can spike four different approaches to a UI problem in the time it used to take to prototype one. This is underrated. Quick exploration before committing to an approach leads to better decisions.
Less context switching: You stop Googling CSS specifics, library APIs, and framework version differences every 10 minutes. The model knows them.
Early-stage velocity: For a new project or feature with no established patterns yet, having the AI scaffold a sensible structure gives you a starting point that's usually better than the one I'd have written quickly on my own.
What you cannot delegate
Vibe coding doesn't replace:
Architecture decisions — where state lives, how modules split, what gets cached. The AI will give you A version of an architecture. It won't necessarily give you the right one for your specific constraints.
Performance reviews — AI-generated code is often correct but not optimal. Bundle size, re-render counts, waterfall requests, and unnecessary useEffect chains still need a human eye. I've caught some egregious stuff in generated code that would've hurt real users.
Security audits — Generated code regularly produces XSS vectors, missing auth checks, and unsafe patterns. Not maliciously — because the training data contains lots of insecure code. Never ship AI-generated code that touches auth, permissions, or user input without reviewing it manually.
Accessibility — Generated UI is frequently missing aria-* attributes, focus management, and keyboard navigation. A screen reader user would be completely lost in most AI-generated interfaces without your intervention.
Test coverage — AI-generated tests tend to test implementation details, not behavior. They'll pass when the code is wrong in ways that matter to users. Review them.
The senior dev skill is shifting from "can write complex code fast" to "can evaluate complex code accurately."
The risks nobody talks about enough
Hallucinated APIs. The model confidently uses a library method that doesn't exist, or a React API from a version three releases back. Always check the actual package version. I've been bitten by this more than once.
Dependency bloat. Every scaffolded feature adds packages. Your package.json grows 3× faster than it would if you were writing manually. Audit what gets added.
Context drift. In long sessions, the AI forgets earlier constraints and produces patterns inconsistent with earlier code in the same session. Break large features into focused sessions.
Over-abstraction. Models love creating utilities, helpers, and base classes for problems that needed three lines of code. Resist the urge to keep it — simpler is almost always better.
Skill erosion. This one is real. Developers who never write code from scratch lose the ability to debug it without AI help. Stay intentional about where you build raw. I deliberately write components and algorithms from scratch regularly to keep the muscle active.
How to prompt well for frontend work
❌ "build me a dashboard"
✅ "Build a Dashboard component in Angular 18 using signals.
It should fetch /api/metrics (types in src/models/metric.model.ts),
show a skeleton loader while loading, and display an error banner
on failure. Use existing TailwindCSS utility classes from our design
system. No new dependencies."
The more constraint you give, the better the output:
- Name the framework and version explicitly
- Point to existing types and files in the repo
- Specify what NOT to do (no new deps, no new abstractions)
- Reference existing patterns ("use the same pattern as UserCard")
A good prompt for frontend work reads like a detailed ticket, not a wish.
Where this is heading
The trajectory is clear: AI will write progressively more of the implementation code. The frontend developer role is evolving toward:
- Product thinking and UX judgment
- System design and architecture
- AI output review and quality gatekeeping
- Performance, accessibility, and security as specializations
Vibe coding is not the end of programming. It's the end of programming as primarily a typing exercise. The developers who'll have an edge in two years aren't the ones who use AI the most — they're the ones who know exactly when to use it and when to think for themselves.