Somewhere in a grocery freezer in the Northeast there is a box of filet mignon. It's marbled. It's premium. The box says so.
It was printed.

That's not a metaphor. In September 2026, Steakholder Foods announced that its Perfecta line of plant-based steak, chicken and salmon had reached retail shelves in the Northeastern US.

The cuts come off industrial 3D printers, one layer at a time, with the "fat" laid down exactly where a cow would have put it. If the cow had read the spec.

And according to reports, nothing on the package tells you a printer was involved. I live in Massachusetts, one of the states on the distribution list. So this is personal.

I've been thinking about that steak a lot lately. Mostly because I keep seeing it in pull requests.

It Looks Exactly Like Steak
Vibe coding works like this. You describe what you want. The model hands you something. It runs. The UI is clean. The buttons have rounded corners. There is a dark mode you didn't ask for. Someone on your team says "wow."

This is the marbled filet in the freezer case.

The demo is the one moment in a program's life where nothing is asked of it. No real users. No bad input. No 3 a.m. traffic spike. No auditor. It just has to sit there under good lighting and look delicious. Generated code is extremely good at sitting under good lighting.

That is not a criticism of the model. That is a description of what it was asked to do. You asked for something that looks like steak. You got it.

The Red Is Beets
A food printer is a shape machine. It is superb at the outside: the grain, the marbling, the exact silhouette of a filet. What's inside is a different question. Reported ingredients for the printed line are soy, wheat and rice proteins, oils, starches, flavorings, and beetroot powder for color.

That is not poison. It's just not what the picture promised.

Vibe-coded apps have beetroot powder too. The outside is perfect. Then you cut in and find:
• Error handling that catches everything and logs nothing
• A retry loop with no backoff, aimed directly at a paid API
• Secrets in a config file, helpfully committed
• A database query inside a loop inside another loop
• Tests that assert the function returns something
• A dependency nobody has heard of, last updated during a previous administration.

None of this shows up in the screenshot. All of it shows up in production. Usually on a Friday.

You're Supposed to Eat This One
The old plastic burger in a restaurant window was honest. Nobody bit it. Everyone understood the deal: a picture of food, made of not-food.

Printed steak is different. It's meant to be eaten. It sits next to real food, priced like premium food, and the label lists what's in it without mentioning how it was made.

That is the vibe coding problem exactly. Generated code doesn't stay in the window as a demo. It goes into the kitchen. It gets plated. It gets served to customers. And nothing on the package says "a model wrote this and nobody read it."

I've been writing software for 45 years. I started in assembly and C, where the machine told you immediately and personally when you were wrong.

Modern tools are far more polite. They'll let you ship the printed filet with a smile. The feedback loop that used to take one segfault now takes one incident review.

In Fairness to the Printer
I'm not anti-printed-food. Food scientists point to real upsides: precise control over texture and nutrition, and help for people with specific dietary needs. Some people will genuinely like it. Taste is personal.

The printer isn't the villain. The villain is skipping the taste test because it looks right.

Same with AI-generated code. It shines for prototypes, spikes, internal tools with one user who is also the author, throwaway scripts, and clickable demos that help a stakeholder say "no, not that" in week one instead of month six. With real engineering behind it, it can absolutely become dinner.

The mistake isn't printing the steak. The mistake is serving it without tasting it.

The Taste Test
Before you serve anything that came out of a prompt, take a bite.

  1. Read it. All of it. If you can't explain a block of code, you don't own it. You're renting it from a model that won't be on call.
  2. Feed it bad input. Empty strings. Huge strings. Unicode. Nulls. The input real users generate while trying to help.
  3. Cut into the middle. Look at error paths, retries, timeouts, and logging. That's where generated code is thinnest.
  4. Read the ingredients. Audit dependencies. Look for secrets. Ask what it can reach and why.
  5. Write the tests yourself. Or at least the assertions. A model writing its own exam is grading on a very generous curve.
  6. Put it under load. Everything tastes fine when nobody's hungry. If it passes, congratulations. You turned a printed shape into a meal. That's real engineering, and the AI genuinely saved you time getting there.

If it fails, also congratulations. You found out in the kitchen instead of the dining room.

Takeaway
AI coding tools are incredible at producing things that look done. Looking done and being done have always been different. We used to have a lot of friction that forced us to notice the gap. Now the gap arrives vacuum-sealed, with dark mode.

So go ahead. Buy the printed steak. Try it. Maybe you'll love it.
Just taste it before you serve it to guests.

What's the best-looking printed steak you've seen merged? Asking for a friend. The friend is my on-call rotation.