Back to writing
April 20, 2025•9 min read

Vibe Coding: Taste-Driven Shipping in the AI Era

A grounded take on vibe coding: how to move fast with AI without breaking conventions, quality, or product feel.

Vibe coding is the name people give to a style of development where the loop is fast, the tool is an LLM, and the feel of the product is a first-class constraint. The phrase is new, but the tension behind it is old: speed versus maintainability, experimentation versus discipline, momentum versus craft.

After reading several pieces from the community and testing the workflow ourselves, here’s the most useful definition we’ve landed on:

Vibe coding is rapid, prompt-driven iteration with a human holding taste, product intent, and codebase conventions steady.

It’s not autopilot. It’s a different ratio of how much you type versus how much you review.

What the web is saying (and why it matters)

1. Vibe coding has a smell. Alex Kondov’s essay on “I Know When You’re Vibe Coding” notes that the most obvious tell isn’t bugs—it’s style drift. The code works, but it ignores local conventions, reimplements existing utilities, or introduces patterns the team has deliberately avoided. The takeaway: the issue is not LLM output, it’s insufficient anchoring to the codebase’s norms.

2. It’s like machine translation. Ingrid’s essay draws a parallel with Google Translate: great for accelerating drafts, risky for nuance and meaning. The analogy maps cleanly to software. LLMs can get you to “roughly correct,” but you still need a human to ensure the result fits the domain language, the team’s style, and the product’s intent.

3. Typed languages make vibing safer. Solmaz’s post argues that typed, compiled languages can actually make vibe coding easier. The compiler becomes a guardrail that catches a large class of mistakes early. The stronger the feedback loop (type checks, lint, tests), the more safely you can move fast.

4. The execution bottleneck is moving. Marius Bălaj’s “vibe coding a bookshelf” story shows a pattern we see a lot: when execution is no longer the bottleneck, the human role shifts to defining the problem, deciding what “done” means, and curating the result.

Together, these pieces suggest a clean approach: use AI for velocity, but design the system so your standards are impossible to ignore.

The workflow we follow

1. Start with a one-sentence feel

We write a short sentence that defines the intended vibe: “calm, deliberate, and premium,” or “fast, playful, and clear.” That sentence becomes a filter for the UI, the copy, and the behavior. If the change doesn’t support the vibe, it doesn’t ship.

2. Anchor the model to local conventions

Before generating anything, we point the agent at the most relevant files and explicitly remind it to reuse existing patterns. This reduces the “LLM smell” and keeps the code cohesive.

3. Build the thinnest slice

We aim for an end-to-end loop that is small but real. A tiny, functional flow is more valuable than a broad, incomplete one. This is where velocity matters most.

4. Run hard checks early

We use whatever guardrails the stack provides: types, lint, tests, and static analysis. The faster these checks run, the more you can iterate without fear.

5. Conduct a vibe review

We review for “feel” in the same way we review for correctness. Does the interaction feel consistent? Is the text sharp? Are the transitions deliberate? If the answer is no, we iterate.

6. Freeze the loop, then expand

Once the core loop feels right and is stable, we scale out. That’s the moment to invest in abstractions, broader edge cases, and performance.

Signals that vibe coding is working

  • The diff is small and focused.
  • The code matches existing conventions.
  • Tests and type checks pass without ceremony.
  • The experience feels sharper after each iteration.

Signals that it’s going wrong

  • New abstractions appear before the workflow is stable.
  • The code introduces patterns the repo avoids.
  • You’re shipping more functionality but with less clarity.
  • The product feels “busy” instead of intentional.

A simple checklist

  • One-sentence vibe statement is visible.
  • Core loop works end-to-end.
  • Conventions reused, not reinvented.
  • Guardrails are green (types, lint, tests).
  • A human explicitly approves the feel.

Closing thought

Vibe coding is not about lowering standards. It’s about moving faster without losing the product’s soul. The better your guardrails and conventions, the more you can trust the speed.

References