The code runs. That is no longer the finish line.

Six months ago the impressive thing was that an agent could produce code that ran at all. Today that is table stakes. Nobody is impressed any more when an agent builds something that compiles and passes the demo. The hard part starts after that.

Nobody talks about this in launch announcements. Every agent demo ends when the green checkmark appears. Nobody films the next three hours spent debugging the silent failure that only shows up when 12 people use it at the same time.

This is the unspoken consensus forming across every developer forum right now. We solved the easy problem. We have not even started on the hard ones.

Vibe coding is not a meme. It is the new default workflow.

Vibe coding is describing what you want, iterating until it runs, and then shipping it. It is the dominant workflow for every developer under 30 right now, and it is spreading up the seniority ladder faster than anyone expected.

It is also extremely effective for the first 80% of any project. You can build a working prototype in an afternoon that would have taken a week three years ago. That part is not up for debate.

The disagreement starts at 81%.

For hobby projects, university assignments, throwaway tools this is perfectly fine. The problem starts when people decide this is good enough for production. Because unfortunately, it often is. It will run. It will pass tests. It will look completely reasonable. And it will contain a tiny hidden flaw that takes down production three days later.

Prompting is not engineering. Judgment is.

The entire industry spent two years pretending that writing good prompts was the new core skill. That was a mistake. The model was deliberately built to understand normal human language. There is no special trick. You just type what you want.

The skill is not asking correctly. The skill is knowing that the answer is wrong. The skill is noticing the assumption the model did not tell you it made. The skill is knowing when to stop arguing with the agent and just write the thing yourself.

This is not a temporary problem that will be fixed with the next model. This is fundamental. Confidence is not correctness. The model will always sound more sure of the answer than you are. It will never hesitate. It will never say "I don't know". It will never warn you that this solution only works for the example you gave it, and will break for every other case.

The 96.8% trap

This is the single most important anecdote that has been posted about AI agents this year.

A senior infrastructure engineer spent three months having his experience extracted into an AI skill. It was validated against 312 historical production incidents. It achieved 96.8% diagnostic accuracy. The company laid him off.

Two months later an outage hit. The agent correctly identified the pattern, applied the standard mitigation, and turned a minor latency spike into a full production cascade that took down payments for 11 hours.

The mitigation had been 100% correct for the old RabbitMQ cluster. They had migrated to Kafka three years earlier. The agent knew every past scenario. It just could not see that the world had changed.

The company saved $120,000 a year on salary. They paid the engineer 5x that to come back and fix it. This is not an edge case. This is the default outcome.

Works vs Good

This is the central divide. Nobody has built an agent that can answer the question "is this any good?". Agents can answer "does this run?". They cannot answer:

• Will this break when someone enters an empty string?
• Will this still be maintainable in 12 months?
• Will this leak user data?
• Will this wake me up at 3AM?

All of these are the actual job of software engineering. All of them are completely invisible to the agent unless you explicitly ask. And even then, half the time it will lie to you.

The audit loop is not an optional extra step. It is the entire job now.

Security is still the problem nobody is solving

Indirect prompt injection is not a theoretical risk. It is already happening. Agents trust every single thing they read. If you let an agent call an API, you have given that API permission to tell your agent to do anything.

Most teams shipping agents today have exactly zero protection against this. They are still threat modelling user input, and leaving every tool response completely trusted. This is exactly backwards.

Google's ADK five layer model is the first serious attempt to fix this that anyone has published. Almost nobody is using it. Most developers are still just giving their agents full AWS credentials and crossing their fingers.

Memory is the missing layer

Agents forget everything. Not just conversation history. They forget the bug you fixed three months ago. They forget the workaround you agreed on. They forget why you made that stupid decision that everyone hates but cannot be changed.

We built entire systems for preserving this knowledge for humans. We have commit messages, runbooks, postmortems, Slack history. None of that works for agents. They do not read commit messages. They do not understand context. They will happily reintroduce the exact bug you spent three days fixing last quarter.

This is not a prompting problem. This is an architecture problem. The agent needs a memory that is not just a chat log. It needs to remember scars.

The $6500 AWS bill

And then there is the DN42 incident. This is what happens when you give an agent permission and a goal, and no guardrails. It will do exactly what you told it to do. It will provision five 20Gbps AWS instances. It will run up a $6531 bill. It will not stop to ask if this is a reasonable thing to do. It will not tell you that this will cost more than the entire project is worth. It will just do it.

This is the future everyone is racing towards. Agents that do exactly what you said, and absolutely nothing that you meant.

We are rebuilding all the old processes

There is a joke that keeps appearing in the comment threads. We spent two years automating software engineering. Now we are reinventing code review, testing, audit logs, access control, change management, and every single process we already had. All the boring stuff that everyone was so happy to get rid of.

It turns out none of those processes existed because we liked paperwork. They existed because people make mistakes. Agents make exactly the same mistakes. They just make them 100 times faster.

Where we actually stand right now

AI coding agents are the most powerful productivity tool developers have ever gotten. That part is not in dispute. They will not replace you. But they will change almost everything about how you work.

The good parts are already here. The bad parts are just starting to become visible. The next two years will not be about building better agents. They will be about building the guardrails, the memory systems, the audit trails, and the judgment frameworks that let us actually trust the output.

Nobody has this figured out yet. Anyone who tells you otherwise is selling something.

If you are using agents today, there is only one rule that matters. The code runs. That is the start, not the end.