Collins Dictionary named “vibe coding” their Word of the Year for 2025. Search interest spiked over 6,000%. The narrative is seductive: describe what you want, AI writes the code, programming becomes as easy as having a conversation.
I’ve spent over a year using these tools professionally — production features, CI pipelines, and this site. Some of the hype is right. A lot of it isn’t.
What Vibe Coding Actually Changes #
The shift is in the feedback loop, not the typing speed. Before AI tools, you had an idea, researched how to implement it, wrote the code, debugged it, iterated. For a non-trivial feature, that cycle ran hours.
With vibe coding, the cycle compresses: describe, review, iterate. And the review step is where all the skill lives. You need to:
- Recognize when generated code has subtle bugs
- Evaluate whether an approach will scale
- Spot security holes in code that looks correct
- Know when the AI is confidently wrong
Senior engineering skills, all of them. You can’t review what you don’t understand.
Where Vibe Coding Shines #
What it’s genuinely good at:
Boilerplate and Scaffolding #
New projects, config files, CI/CD pipelines. The work is well-documented, pattern-heavy, tedious — and there’s almost always a clear “right answer” sitting in the training data.
Setting up Cloudflare Pages deployment for this site, Claude Code generated a working GitHub Actions workflow on the first try. That’s 30-45 minutes of docs-reading I didn’t do.
Test Generation #
Describe the behavior you want to test, get reasonable test cases. Often surprisingly good at edge cases I wouldn’t have thought of. I use it most heavily for the scaffolding of test suites — assertions still get a human review, but the structural typing is gone.
Documentation and Content #
Docstrings, README sections, code comments derived from existing code. The AI reads the implementation and describes what it does faster than I can type it.
Learning New Frameworks #
Adopting the Blowfish theme for Hugo, I explored its shortcodes and config options conversationally instead of reading documentation linearly. “I want a timeline component showing my workflow” gave back working code that taught me the API in the process.
Where Vibe Coding Fails #
Sometimes it just doesn’t work. Sometimes it fails in dangerous ways.
Architecture Decisions #
When I started this site, I had to decide: Hugo or Next.js? Content pages or data templates for the experience sections? Single config file or Blowfish’s multi-file approach? These decisions have cascading consequences. An AI can implement any of them. It can’t tell you which one you’ll regret in six months.
Security #
Generated code takes the happy path. Often it doesn’t sanitize inputs, doesn’t handle authentication edge cases, doesn’t follow least-privilege. Shipping unreviewed AI-generated code into production is a liability.
Performance Optimization #
AI tools produce code that works, not code that’s fast. They don’t profile your application or understand your data access patterns. They won’t tell you about the N+1 query that’s going to tank your API at scale. Performance is system-shaped reasoning — exactly the kind AI tools struggle with.
Debugging Complex Issues #
Race conditions, subtle state management bugs, infrastructure quirks — when something goes wrong in a way that isn’t a simple syntax error, you need deep understanding of the system. AI tools can answer “what does this error message mean?” They can’t replace the mental model you’ve built over years of working with that system.
The Skill Shift: Writing Code to Directing AI #
A year in, here’s what changed in my own work.
I write less code. Keystroke count is probably down 40-50%. Output hasn’t dropped. If anything, I ship more features.
I review more code. Every AI-generated change gets the same scrutiny I’d give a junior developer’s pull request. More, honestly — a junior developer at least understands the codebase they’re touching.
I make more decisions. With the implementation bottleneck reduced, decision-making becomes the constraint: what to build, how to structure it, which tradeoffs to accept. Skills that take years to develop.
I communicate more precisely. Writing good prompts turns out to look a lot like writing good technical specs. You’re clear about requirements, constraints, expected behavior. Vague specs produce vague results — from humans and AI alike.
The METR Study: Faster Feels, Slower Results #
In 2025, METR (Model Evaluation & Threat Research) ran a study that landed harder than expected: experienced developers using AI coding tools were 19% slower on real-world tasks but felt 20% faster.
Why the disconnect?
- Context-switching cost — Reviewing AI output, correcting mistakes, iterating on prompts: time that doesn’t feel like “work.”
- False starts — AI-generated code sometimes takes you down a wrong path, and backtracking erases the time savings.
- Quality gaps — Code that “works” on the first try often needs revision for edge cases, error handling, and production readiness.
- Confidence bias — Getting code instantly feels fast, even when the total cycle time (prompt → review → fix → test) ran longer.
This doesn’t make AI tools useless. The value just isn’t raw speed; it’s the type of tasks that become feasible. I wouldn’t have attempted a full Hugo site with custom theme configuration, CI/CD, and a dozen interlinked blog posts in a weekend without AI assistance. The absolute time per task may not drop. The ambition ceiling rises.
quadrantChart
title When to Vibe Code vs Hand-Code
x-axis Low Complexity --> High Complexity
y-axis Low Familiarity --> High Familiarity
quadrant-1 Hand-code
quadrant-2 Either approach works
quadrant-3 Vibe code
quadrant-4 Vibe code with careful review
My Framework: When to Vibe Code #
After a year of daily use, my decision process looks like this.
Vibe code when:
- The task is well-defined with clear inputs and outputs
- Established patterns or documentation exist to draw from
- Blast radius of a mistake is low (config files, tests, documentation)
- You’re scaffolding something new, not modifying something complex
- You understand the domain well enough to review the output effectively
Hand-code when:
- The task requires deep understanding of existing system behavior
- Security or performance are critical
- You’re debugging something subtle
- The architectural approach isn’t settled
- You need to think through the problem, not just implement a solution
A simpler rule: if you wouldn’t trust a junior developer’s PR for this task without extensive review, don’t trust AI-generated code either. If you would, that’s a great vibe-coding candidate.
Predictions for 2027 and Beyond #
Reading from the trajectory so far:
-
Context windows will keep growing. The biggest limitation of current tools is losing context in long sessions. As context windows expand, the range of tasks suitable for vibe coding grows with them.
-
Review tools will emerge. Right now, reviewing AI-generated code uses the same tools as reviewing human code. Expect specialized tools that surface common AI failure modes — security anti-patterns, performance pitfalls, outdated APIs.
-
The skill premium shifts. The most valuable engineering skill becomes the ability to evaluate, direct, and integrate AI output into production systems. System design, not syntax knowledge.
-
Hybrid workflows become standard. The “AI vs. no AI” debate will sound as quaint as “IDE vs. text editor.” Every engineer will use AI tools. The differentiator: how effectively.
-
Junior engineers face a steeper learning curve. Skip the fundamentals and rely on AI from day one, and you’ll lack the knowledge needed to review AI output. The engineers who’ll thrive learn to code and then learn to direct AI.
Vibe coding is a leverage multiplier. It amplifies whatever skills you already bring. For senior engineers with strong fundamentals, system design experience, and judgment, it’s a genuine superpower. For anyone hoping it replaces the need to understand software engineering — that’s the hype talking.
My daily workflow with Claude Code is detailed in this post, and I compare the major tools in my 2026 tool comparison.