Vibe coding, minus the vibes

Last week I watched an agent write a Rust module I'd put up against most senior engineers' work. Lazily-compiled regexes behind OnceLock. A small, documented helper reproducing JavaScript's lenient parseFloat semantics — a subtlety nobody asked it to handle. Clean branches, honest types, zero dead code. A reviewer skimming it would swear a careful human wrote it.

Here's what makes that interesting: the same class of model, on a normal day, produces the code we've all learned to squint at. Happy-path tests. Abstractions nobody needed. Logic that's plausible right up until it's wrong. We have a name for that output now — vibe coding — and the discourse about it has exactly two settings: "this is the future" and "this is slop."

Both miss what vibe actually is.

Vibe is uncertainty made visible

A model fills every degree of freedom your problem leaves unconstrained with its priors — the averaged habits of all the code it has ever seen. Vague ask, vibey answer: the happy-path bias, the hedge-everything error handling, the kitchen-sink config object. None of that is the model misbehaving. It's the model answering the question you actually asked, which was underspecified, so it padded the gaps with vibes.

The slop isn't in the model. It's in the leftover freedom.

That reframe changes the fix. If vibe were an intelligence problem, you'd wait for a smarter model. If it's a freedom problem, you can squeeze it out — mechanically, today.

The squeeze

This is the loop rederive is built on. Four moves, each one removing a class of freedom:

• 1 A contract — the unit's behavior, written precisely enough that independent engineers reading it would converge, including the ugly parts (regexes transcribed verbatim, because prose can't carry a lookahead).
• 2 An oracle the author can't move — hundreds of input→output cases stamped by executing the real code, never hand-authored, with a held-out set the implementer never sees. Plausible earns nothing; only correct passes.
• 3 A clean room — the implementer gets the contract and the examples. Not the original source. Nothing to copy, nothing to wander into.
• 4 Independent rebuilds that must agree — several, blind to each other, graded on the cases none of them saw.

What it looks like when the freedom is gone

We ran this on a color-parsing package millions of projects depend on. Along the way, characterization surfaced a real bug — a floating-point rounding slip that renders rgb(50%, 50%, 50%) one shade off (127 instead of 128; 2.55 isn't exactly representable, and no test had ever noticed). We didn't patch the code. We corrected the contract, and let the machine rebuild from that.

Three agents rebuilt the unit in JavaScript, blind, in parallel. All three passed every held-out case. All three agreed with each other on five thousand randomized inputs — and structurally, they'd written nearly the same program: same shape, same helper, same hoisted constants. Then, as a lark, we handed the identical contract to a fourth agent and said: Rust.

# one contract → four blind reconstructions
  emit_1 (js)   5000/5000
  emit_2 (js)   5000/5000   ← agree with each other
  emit_3 (js)   5000/5000
  emit_4 (rust) 5000/5000   ← byte-identical behavior to the JS builds

The Rust agent fought through real language friction on its own — Rust's standard regex crate doesn't support lookahead, so it found the crate that does; JavaScript's number parsing is lenient, so it wrote and documented a bridge for exactly that semantic. The bug is fixed in every version — by agents that never saw the buggy line.

That Rust is the gorgeous module from the opening. Nobody told any of these agents to write clean code. There was just nothing left to be messy about. Every decision a model normally vibes through — structure, behavior, edge cases, garbage input — was already decided by the contract and enforced by the oracle. What remained was the one thing models are genuinely great at: fluent, idiomatic expression.

Vibe diverges; certainty converges

That's the tell I now use everywhere. Ask an agent for the same thing three times and you'll get three aesthetics, three bug profiles, three vibes — that's the prior talking. Constrain the problem fully and independent attempts collapse onto the same solution.

Steal this, even without our tooling

• — Write the contract before the prompt. If you can't state what the code must do precisely enough for a stranger to converge on it, the model can't either — and it will fill the difference with vibes.
• — Make your tests un-gameable. Expected values from execution or spec, never from the model that wrote the code. Run mutation testing against your suite once — the number will change how you sleep.
• — Judge AI output by convergence, not confidence. Generate twice, independently; where the attempts disagree, your spec is thin.

"Vibe coding" was never a fixed property of the technology. Freedom is a dial. Turn it down with contracts and ungameable checks, and the same models that produce slop produce work that converges, verifies, and reads like a careful human on their best day.

We've spent the last months turning that dial into infrastructure. It's called rederive, it's open source, and it's live: npm i -g rederive.