Every developer who has been around a while has heard the excuse, usually delivered with a shrug: "works on my machine." The bug is real, the user is not lying, and the developer genuinely cannot reproduce it, because their laptop has a library version, an environment variable, or a cached file that the server does not. The phrase became a joke because it was always technically true and completely useless. We are now watching the exact same failure reappear in a new costume, and it says "it works on my prompt."
You have seen it. Someone demos a prompt that produces a perfect answer. It goes into the product. Within a day the support channel fills with outputs that are wrong, malformed, or unhinged, and the author is baffled, because it worked when they ran it. It did work when they ran it. That is precisely the problem, and it is the same problem we thought we solved twenty years ago.
Same disease, new organ
The old bug came from an environment you did not control and could not see. Your machine had state that the deployment target did not share, so behavior that depended on that hidden state broke the moment it moved.
A prompt has the same hidden state, just in different places. When you tested it, you fed it your clean example, in your phrasing, on the model version you happened to be pointed at that afternoon. Production feeds it a user who writes in fragments, pastes an emoji, switches to Spanish halfway through, or sends the empty string. Same prompt, wildly different input distribution. The prompt did not change. The world around it did, and the prompt had no defenses because you only ever tested it in the world where it worked.
There is a second layer that makes it worse than the original. The old bug was at least deterministic. Given the same machine and the same input, you got the same result every time. A language model is not deterministic by default. The identical prompt with the identical input can return a good answer now and a broken one on the next call. "Works on my prompt" is therefore weaker than "works on my machine," because it does not even reliably work on your prompt. It worked the three times you tried it, and you called that done.
We already know the cure
Here is the part that should be encouraging. The industry did not just complain about "works on my machine" for two decades. We killed it, with a set of practices so ordinary now that juniors assume they always existed: version everything, test against realistic inputs in an environment that mirrors production, put it all in a pipeline that runs before anything ships. The discipline was the answer. The same discipline is the answer here, and prompt engineering is mostly refusing to relearn it the hard way.
What that looks like in practice is not exotic. Pin your model version, because a silent upgrade is a config change that can break every prompt at once. Keep a real test set of messy, adversarial, empty, and multilingual inputs, and run your prompt against all of them, not against the one clean example that made the demo look good. Run each case more than once, because a single pass through a non-deterministic system tells you almost nothing. And gate deployment on those results, so a prompt cannot reach users until it has survived the ugly inputs.
None of this is new thinking. It is testing and version control and continuous integration, pointed at a prompt instead of a binary. The reason teams skip it is that prompts feel like writing, not engineering. You type a sentence in plain English, the model does something clever, and it looks less like code than a note to a coworker. That feeling is the trap. A prompt is a program with an input space larger and stranger than any function you have ever written, and treating it as casual text is how you end up shipping the empty string straight into production.
The teams that will be trusted with AI features are not the ones with the cleverest prompts. They are the ones who looked at "it works on my prompt," recognized an old enemy in a new coat, and reached for the boring tools that beat it the first time. The excuse was funny once. Please do not make us laugh at it twice.