Vibe coding with LLMs feels like having superpowers until you realize you're just swimming in a sea of digital spaghetti with a fried brain.

The tools are magic, but moving at 10x speed is a psychological trap. If you don't build a systemized framework around how you use them, you're not an engineer anymore-you're just an easily stressed middleman for an AI's hallucinations.

The real skill isn't prompt engineering; it's engineering management.

You have to treat the LLM like a hyper-fast, slightly chaotic junior dev. That means aggressively wiping your chat context clean the second a sub-feature works, forcing strict modular architecture so it doesn't vomit out a 600-line monolith, and stepping in the exact moment you hit a "3-prompt death loop" instead of blindly hitting generate.

Vibe coding works because we stop reviewing every step. We describe what we want, the agent gets on with it, and we look at the result. That speed is the whole point, and I don't think anyone wants to go back to approving every command.

But it means the agent is running commands, reading files, installing packages and calling tools with our own permissions, mostly unwatched. When something goes wrong, the transcript doesn't help much: it's a conversation, not a record of what actually happened on the machine.

For a long time that felt fine to me. Then I started recording every action my own agents took, and looked at a few days of it.

What surprised me wasn't any single command. It was the combinations. Reading a file with credentials in it is normal. Calling a cloud API is normal. The same session doing one and then the other, without me asking for either, is the kind of thing I want to at least notice. Some of what got flagged I could explain right away. A few I'm still going through, which is exactly the point: without the record, I wouldn't even know there was something to look at.

The failures that hurt are never the ones that crash. A crash gets a stack trace and a fix the same day. The expensive ones return 200, render a normal looking screen, and sit there.

My own version was on iOS. A products fetch came back empty, so the purchase button stayed greyed out. No error, no log line, nothing to alert on. The reviewer found it before I did.

So I'm curious:

What did an agent quietly break in your project?

Vibe-coding is fun for me. I do not have to necessarily write all that big codes and pages manually as AI easily does that for me. But, I also realized that it is very important for me and you to know what code does that AI write.

I personally feel that AI is good in assisting the work but entirely leaving it to AI and not even checking would be dangerous in near time if not now. AI makes mistakes, and those mistakes can be costly for humans who used them to code.

I still design in Adobe first. It's in my fingers, like being used to writing notes with a pen and then having to do everything on a computer.

After that I bring it to life with AI, which opens up a lot I couldn't do on my own before. But I don't want to skip the first part. That's where I actually think.

One small change has made my AI coding sessions much easier to control.

Before asking the agent to implement a non-trivial feature, I now ask it to write a short implementation plan first.

My current setup is basically:

Claude checks Codex -> Codex checks Claude -> ChatGPT checks both

I m not a developer, have someone who can help to verify and triple check security issues, but still so at some point I have to trust the AI which is exactly why I make them check each other about 500 times.

Two hours into a refactor yesterday, my agent wrote a helper function the exact same one it wrote 90 minutes earlier in a file it created itself. Then it apologized. It always apologizes.

The easy diagnosis is "it ran out of context". Except my session was sitting at 120K in a 200K window. Nothing overflowed. The context didn't run out it rotted.

You have two budgets, not one:

• Hard Budget: Token limit. You notice it when the API errors out.

• Soft Budget: Attention quality. It drains silently long before you hit the limit.

I spent most of my career doing non-technical work, and I now build our product, @HeyNews. I got there by talking to AI coding agents night after night. The catch: the agents are good company right up until 4am, when you're still hitting approve every thirty seconds and what you actually want is sleep.

So I built a loop I can walk away from and wrote up exactly how it works: https://blog.heynews.co/afk-codi...

We started routing the easy stuff to a small model to save money. Cost per request dropped about 40% and the dashboard looked great. What the dashboard didn't show was people re-sending the same message, so once you count the retry and the follow up clarification, the cheap path burned more tokens than just sending it to the big model once.

The mistake wasn't the routing. It was measuring cost per request instead of cost per finished task. A request that has to be asked twice isn't cheap, it's a request plus a support ticket forming.