Are we confusing speed with progress in vibe coding

Situation(s)

Four months back, if I wanted a feature, I wrote tickets. Or worse, I wrote a spec that nobody read.

And here we are — last week I typed two sentences into an agent, walked to the kitchen for chai, and came back to a working screen. 40 seconds. Maybe less. A thing that did not exist was now a thing that existed, with a database, a login, and a slightly smug "Done ✅" message at the end.

I have been chasing that feeling since February 2025, when Andrej Karpathy coined "vibe coding" and English quietly became the coding language. It is genuinely intoxicating. The gap between wanting software and having software has collapsed to almost nothing.

I have also, in that same period, shipped less than I expected. And I have been trying to understand why.

Complication(s)

Here is the uncomfortable part. The speed is real. The progress isn't always.

The 40 seconds is the visible part. The 4 hours that follow are invisible — reading the diff, deciding whether the auth flow is right, noticing that the agent solved the problem I typed rather than the problem I meant, quietly wondering if I should have used a different table name, then changing it twice.

The work didn't disappear. It moved.

When typing was expensive, the cost of a mistake was a thought. You couldn't type ten pages by accident. Now the cost of a mistake is a review. And reviews don't scale the way generation does. Generation jumped by a factor of a hundred. Reviewing is still a human, reading, one line at a time.

This is the same thing I wrote about in July — that generic skills go first and expertise stays. But I think I understated it. It's not that developers lose typing and gain judgement. It's that the whole job becomes judgement, undiluted, all day, with no filler. And most of us have never actually done that. We spent twenty years doing 60% mechanical work and calling ourselves engineers.

Question(s)

So here's my question.

If everyone can build, what exactly is the difference between two people building?

And the sharper one: are we measuring the right thing when we say AI made us faster — or are we measuring the 40 seconds and ignoring the four hours?

Answer(s)

My take is — the bottleneck moved from typing to deciding, and almost nobody has retooled for the new bottleneck. We bought faster tools and kept the same mental assembly line.

The speed is real. The progress is contested. And the gap between them has a name.

Here are my 3 reasons:

Intent Cost:

Tokens are cheap now. Clarity is not, and it never was. The expensive object in the room is knowing what you actually want — and no model arrives with that.

I have started noticing how often I hit generate before I have finished thinking. The agent doesn't care. It will happily build my half-formed idea, competently, forever. Then I'll commission a second version, and a third, because the problem was upstream of the prompt. Prompting clearer is a waste of effort when you're prompting clarity you don't have.

The people who look magical in 2026 are not the ones with the best models. They're the ones who can articulate a thing precisely before they build it. That was always the hard skill. It just couldn't be hidden behind other work before.

Review Debt:

Generating 2,000 lines takes 40 seconds. Reviewing 2,000 lines takes two hours, if you're careless. Four, if you're honest.

So the debt didn't vanish — it moved downstream, where it's less visible and therefore less budgeted. And worse, it compounds. Every unreviewed shortcut becomes the ground the next feature stands on. Three weeks later the agent is building on top of decisions nobody, including you, ever formally made.

Bluntly, this is GIGO at organisational scale. Garbage in, garbage out — but now the garbage is architectural, and the out is a codebase you can't reason about.

The person who can review fast, because they know what good looks like, is now worth ten times more than the person who can generate fast. And the second person costs nothing.

Taste as the Scarce Resource:

When everyone can build, the only remaining differentiator is knowing which build is worth shipping.

This is the part that makes people uncomfortable, because taste doesn't have a curriculum. You can't buy it on the OpenRouter dashboard. It comes from having shipped bad things, watched them fail, and developed an opinion that you're willing to defend in a meeting.

I have a folder of projects that were technically impressive and quietly useless. Good, clean, well-structured, and abandoned by week two. Nothing in them was broken. Nothing in them was necessary either. An agent built every single one, perfectly, because it had no view on whether the thing should exist. And — this is the uncomfortable bit — neither did I, until after it existed.

Taste is the one thing that also gets better with the tools — it just doesn't get better automatically.

The deciding tax

That's what I've started calling it. The work that survives automation.

Every round of automation in my lifetime has looked the same. The visible task gets cheaper, and the invisible judgement behind it gets more expensive. Spreadsheets made arithmetic free and made modelling the scarce skill. Search made information free and made knowing what to look for the scarce skill. Now generation is free and deciding is the scarce skill.

The deciding tax isn't payable later. It's payable up front, in the boring hours before you type anything — writing down what you actually need, what you're willing to give up, and what "done" means. Which is the least fun part of the job and always was.

My take is that 2026 belongs to whoever pays that tax willingly, in advance, before the 40 seconds starts.

Everyone else gets a beautiful thing they didn't need, four hours late.

The generation curve is going to keep going up. The deciding curve is not. That gap is where the profession now lives — and honestly, it's a much more interesting place to work than where we were.