Vibe Coding, From a Shop That Ships With It

I run a small media shop, and most of what we ship now — websites, measurement tools, videos, test programmes — gets built the same way: I describe what I want, an AI builder writes it, and my hours go to steering and checking instead of typing.

Vibe coding is describing what you want built in plain language and letting an AI builder write the code — you steer with intent and judgment, and it does the typing.

Andrej Karpathy put the name on it in early 2025: “fully giving in to the vibes.” The phrase stuck because it is honest about the feeling. You stop writing the code line by line. You talk, the machine builds, and you judge what comes back. What the phrase leaves out — and what nobody tells you until you run a real shop this way — is where the work actually went. It didn’t disappear. It moved.

What it looks like from this desk

Nobody here opens a blank file and starts chatting at a builder and hoping. The work runs on written work orders: a commission that says what the finished thing is, what it has to connect to, what it must never do, and what proof comes back when it’s done. The builder — we run several, in different seats, with different jobs — executes against that order. Then the return gets checked: not skimmed, checked. Claims get compared against sources. Numbers get tied back to where they came from. Pages get fetched live and read the way a visitor would read them.

That seat discipline matters more than the model does. A builder with a lane, a written order, and a receipt to produce behaves like a contractor. A builder with a vague prompt and no checking behaves like a confident intern who never sleeps and never admits he’s lost. We wrote up how the seats are governed in our piece on running six AI seats on one business, and the short version is: the structure is the skill. The prompt is the smallest part of it.

What shipped

Talk is cheap in this trade, so here is what actually went out the door from this shop, built this way:

• A citation-measurement programme across a fleet of niche sites. We track where AI answer engines cite our pages and where they don’t, topic by topic, site by site — that map drives what gets written next, instead of guessing.
• A nightly board that re-pulls our own citation numbers and republishes them. Every night it goes back to the source data, rebuilds the tally, and posts the current standings. If the numbers move, the board moves. Nobody hand-types a figure into it, which means nobody can quietly round one in our favour.
• Article-to-video pairs, built in-house. Script, scenes, narration, captions — produced here, published as pairs: the article and its video, each pointing at the other. Nine pairs are live. The most recent one is Half the Citations Sit on Three Pages, which is itself a finding out of the measurement programme — the work feeds the work.
• An anchor experiment, installed live on November 7. We put anchor links on article section headings so each section can travel as its own citable piece — the way a video chapter does. It’s running now and being measured. It might work. It might not. Either way we’ll know from the data, not from a feeling.
• A full inventory-test programme run against a real product. Not a demo on our own toy data — a scored test, run in the open inside the shop, with results written down whether they flattered anybody or not.

That’s the part of vibe coding the tool ads get right: the volume is real, and a small shop can ship like a bigger one. Now the other half.

What broke

Everything on this list cost us time, and every item on it taught the same lesson from a different angle.

• Invented facts, caught at the gate. Our page-refresh programme ran in waves, and a pattern showed up in the returns: builders writing plausible, confident, wrong facts into refreshed pages — vendor details, protocol claims, numbers that sounded right and weren’t. None of it shipped, because every claim got checked against a source before publish. But “none of it shipped” is doing a lot of work in that sentence. Without the gate, it all ships. That is the default outcome of vibe coding without a checker: fluent fiction at production speed.
• A page and its PDF, saying two different things. We’d fix a page and leave its downloadable PDF stale, so a reader with the old file in their own system was working from numbers we’d already corrected. The fix became a standing rule: a page and its download are one asset. The PDF gets regenerated from the corrected content in the same run, or the edit doesn’t ship. The builder never once flagged the drift on its own. A human had to notice the pattern and make it a rule.
• Runs that stalled on things nobody priced. Quota running out mid-programme. A token that didn’t cover the sites the job needed. A browser on a busy desktop that couldn’t be borrowed. Each one stopped a run cold, and each one was knowable before the run started — somebody just hadn’t checked the whole path to the finish.
• A redirect job priced at the start instead of the finish. The estimate covered beginning the work, not completing it, and the job froze partway with the loose ends live. It got sorted, but the scar tissue became another rule: price the finish, not the start — the whole path, including whether the human has to stand there while it runs.

Read those four back and the pattern is plain: the builder’s confidence is not evidence. Not one of those failures was a typing failure. The code worked. The words were spelled right. What failed was truth, scope, and follow-through — the exact things a confident machine will never flag about itself. The operator’s checking is not a quality step added to vibe coding. It is the product. The building is the commodity.

The honest split of labour

Here is how the work actually divides in this shop. The machine is fast at the typing and tireless at the volume. It will rebuild a board every night forever and never get bored. It will draft the fortieth page in a wave with the same energy as the first. It does not get tired, and that is genuinely new in the world — a two-person shop with tireless hands.

The human carries everything the machine can’t: the intent (what should exist and why), the taste (this is good enough, this is not), the fact-check (this claim is true, that one is invented), and the stop button (this run ends here, this door doesn’t open). Those four things sound soft next to “writes code.” In practice they are the whole job, and they were always the whole job — the typing was just where the hours used to hide.

We have a phrase for it here: partway is the point. The skill isn’t prompting. The skill is knowing which 80% to let run and which 20% is yours — and never confusing the two. Let the machine run the 80% and it will carry you further in a week than a year of typing. Hand it your 20% — the judgment, the verification, the calls — and it will carry you straight into a wall, politely, at speed, with perfect formatting.

What it is not

It is not “anyone can build anything now.” Anyone can get something built. The question was never whether the machine can produce the thing — it’s whether the thing is right, and knowing that takes judgment the subscription doesn’t include. Judgment is the scarce input, and it’s scarcer than it was, because now it has to cover ten times the output.

It is not the end of programmers. Somebody still has to know when the output is wrong, and “wrong” gets subtle fast: the code runs, the page loads, and the fact on it is invented. The people who’ll do best in this aren’t the ones who type fastest or prompt cleverest. They’re the ones who can read a return the way an editor reads a draft — for what it claims, not how it sounds.

It is not a vibe you can skip verifying. The name is the most dangerous thing about it. “Vibe” suggests the checking is optional, a personality choice for nervous people. In a shop that ships to real readers, verification is the difference between a production system and a fiction generator with good uptime. Give in to the vibes on the typing. Never on the truth.

So here’s where this shop lands on the term. It sounds like the work got softer — like building things turned into lounging with a laptop and a feeling. From inside, it got more honest. The typing used to hide the judgment; now the judgment is all that’s left, and it shows. A piece either has its receipts or it doesn’t. The facts either check or they don’t. The thing either shipped or it’s a story about shipping.

That’s a harder standard than the old one, and it’s a better one. We’ll keep building this way.

Frequently asked questions

What is vibe coding?

Vibe coding is building software and content by describing what you want in plain language and letting an AI builder write the code, while you steer with intent and judgment. Andrej Karpathy named it in early 2025, describing it as “fully giving in to the vibes.” In a working shop, the steering and the checking are most of the job.

Is vibe coding good or bad?

Neither — it’s a method, and the result depends on what surrounds it. With written work orders, clear boundaries, and a hard check on everything before it ships, it lets a small shop produce at a scale that used to take a team. Without the checking, it produces confident mistakes faster than any method in history. The vibe is not the variable. The verification is.

Do you need to know how to code to vibe code?

You need to know how to judge, which is a different thing. You don’t have to write the code, but you do have to be able to tell whether what came back is right — whether the facts check, the scope held, and the thing actually does what it claims. If you can’t tell, you need someone beside you who can. That judgment is the part you can’t hand off.