Vibe Coding Has Two Axes. The Second One Doesn't Get Cheaper

Cession is one dimension. Verification is the other, and no model release moves it for you.

A week and a half ago I wrote a short post arguing that vibe coding is not a skill level. It is an axis. A dial you set per task: how much of the work you hand to the model, and how much you keep steering yourself. A senior engineer scaffolding a throwaway script is further up the dial than a beginner hand-checking something that matters. The same person slides up and down ten times a day.

I shipped that, people nodded, and I moved on. Since then I wrote about trading bots that lied, agents that drifted, track records that audited themselves, and markdown files that quietly went stale. Half a dozen posts. At some point it got embarrassing how much they were all the same post.

Because the axis was right and incomplete. An axis is one dimension. And the thing I kept circling, in every one of those posts, was the dimension I had left out.

Every position on the cede-to-the-model dial has a price. The price is verification.

Here is the part the ladder framing hides. When you move up the dial and hand more to the model, the work does not get easier. It changes shape. You stop writing the thing and start checking a thing you did not write. The labor moves from production to inspection. That is still engineering. It just looks more like test design, threat modeling, and acceptance criteria than like typing code. And inspection of confident, fluent, plausible output is its own skill, one the last few decades of programming did not require, because for most of that history the person who produced the code and the person who understood it were the same person.

So there are two axes, not one. How much you cede. How much you verify. Plot them.

The diagonal is where it works. Cede a little, verify a little: you hand-write a function and read it as you go. The stakes are local, the check stays close, both are matched. Cede a lot, verify a lot: you let the agent build the whole module, then run it against tests you wrote before you saw its code, and read the diff like you do not trust it, because you do not. Both are honest, because the checking rises to meet the trust.

Off the diagonal is where it goes wrong, in two directions. Cede a little, verify a lot is the cheaper mistake: you distrust the model on work it would have gotten right and pay for it in time. Overchecking, busywork, wasteful but harmless.

Cede a lot, verify nothing is the expensive one. That is the agent that deleted the database, the bot that reported four days of trading it never did, the refactor that passed every vibe and broke in production. None of those are failures of cession. They are failures of an empty second axis.

And notice what the failure actually looks like at the top of the dial. It is not bad code that announces itself. It is code that reads clean, sounds sure, and is quietly wrong. The model does not get less articulate as it gets less correct. Fluency and accuracy come apart, and every instinct you have for catching errors, does this look careful, does this read coherently, is now pointed the wrong way. The output is camouflage, and it is good at it.

This is why I think the second axis is the whole job now, and getting bigger.

Better models move you up the cede axis for free. That is the entire pitch of every release. Hand us more, steer less. What no release moves, on its own, is your position on the verify axis.

Not all verification is equal. A model reviewing its own output in the same run is the weak case: the producer signing off on its own work, confident either way. Push the checker further outside the producing process and it starts to bite. A test suite you wrote before seeing the code, a CI run, production telemetry: each sits a little further out, and each catches what the layer below it waved through. Self-review is one end. A real-world consequence is the other.

So the gap between the two axes widens with every model that gets better. Cession gets cheaper. Verification does not. The skill did not disappear when the model started writing your code. It relocated. It moved from knowing how to build the thing to knowing how to test a thing you did not build, against something the thing cannot rewrite.

That last clause took me half a dozen posts to say plainly. The moment your verification lives inside the same process that produced the work, you are back to self-attestation, and self-attestation scales perfectly with how wrong you are. The whole game is getting the check far enough outside the work that the work cannot talk its way past it.

Which means the original post had the easy half. Vibe coding is an axis, yes. Slide freely. The part I left out is that the axis has a twin bolted to it, and the twin does not move on its own. You climb the cede axis by buying a better model. You climb the verify axis by building something the model cannot talk its way past.

The first post was about identity: vibe coding is not a kind of person. This one is about responsibility: every setting on the dial needs a matching check.

Vibe coding was never the risky part. Vibe coding with an empty second axis is. Move them together. Up or down, but together.

The original post: Vibe coding is not a level, it's an axis (dev.to).