Over the weekend, I vibe coded a cooking game. You combine random ingredients, and the game generates a dish with a score and a snarky review — stuff like "This tastes like regret and too much butter." I'd wanted to build this for a while. Eventually I'll hook it up to an AI model to generate more combinations and even harsher critiques.
One Prompt, One Hour
I opened Claude Code and typed a single prompt:
"Create a cooking game where players combine ingredients to discover recipes..."
An hour of coding and debugging later, I had a working version running on localhost.
The Wall
Then came the real problem: deploying it so my friends could actually play.
AI has collapsed the barrier to building software. But no matter how low the entry gets, even the most seasoned SRE can't rattle off HTTPS configs, domain setups, and nginx routing rules from memory. As a vibe coder, what was I supposed to do next?
The Plan
I spun up an AWS VM, installed a Knox Daemon (Knox is an AIOps product), and connected it to my GitHub repo. Then I told it:
"How I Shipped My Vibe-Coded Code to Production"
It started exploring my codebase. It discussed the task with me, asked clarifying questions, and came back with a full plan — five stages covering pre-checks, building the game, requesting certificates, updating nginx routes, final verification, and documenting what it learned for next time. Nothing would execute until I approved it.
The Execution
I reviewed the plan and hit approve. The agents kicked off in parallel — one checking the environment, one executing changes, another validating the output of each stage. They ran efficiently, every step visible. It looked exactly like a human SRE team at work.
When it was done, the agent handed me a report. I clicked the URL in the report and — there it was. My game. Live. Someone could play it.
30 Minutes
I was doing other things throughout the deployment, so I wasn't always quick to respond when the agent needed input — requirement discussions, plan approval, execution confirmations on my AWS box. Total time from start to live: about an hour. If I'd been fully focused, probably 30 minutes.
The whole experience was striking. More and more people are building things in the AI era. They think about product design and development, but then what? How do you deploy? How do you keep the service running?
I think this is what agentic ops means.
Agentic ops gives you the same answer: describe what you want, and an agent operates the server. Same loop as vibe coding. The output just isn't code anymore — it's a running service.
The endpoint of vibe coding shouldn't be localhost:3000. It should be a link you can drop in a group chat.
Top comments (2)
Shipping vibe-coded code to prod is the real test, the demo is easy, the part that separates it from a toy is exactly the ops layer you're tackling: does it deploy cleanly, survive real traffic, and can you debug it when it breaks at 2am. The trap with vibe-coded code is it's plausible right up until prod exercises the path the model never considered. A hard verify-and-deploy gate (it builds, it runs, it's actually wired) is what makes shipping it safe rather than a gamble. That's the core of how Moonshift ships: generate is step one, prove-it-runs-and-deploy is the real work. What was scariest about putting vibe-coded code in prod, the debuggability or the unknowns?
Hard agree on the "plausible right up until prod" trap. For us, the scariest part was neither — it was trust. What if the agent's fix is wrong and makes it worse? That's why we built the human gate at every destructive action. Deploy clean is step one. Deploy safe is the rest.