From Vibe Coding to Procedural Automation

Engineering innovative software in the age of AI is an exciting prospect, but it comes with pitfalls and unknowns. AI offers the opportunity to accelerate innovation, helping us discover new ways of solving problems and developing solutions in a fraction of the time. However, overuse of AI can lead to slop—eroding quality, increasing technical debt, and ultimately slowing progress. There is perhaps a better way to leverage AI to accelerate software innovation, and this article proposes once such approach.

Vibe Coding

Let’s look at vibe coding as an example of how to accelerate software innovation.

You can prompt an AI tool to build a solution to an unsolved problem and ask it to publish the result in a usable format. For example:

“Write me an app that does this … and deploy it in a cloud framework so I can use it in a web browser.”

The AI thinks, outlines the steps, executes them, and—done. A web page is published with a solution built-in. If you are lucky (and that is rare), the solution works first time and does exactly what you asked. More often, however, it is close but not quite right.

You review the generated code, hoping a small tweak will get you there. You understand what it did, but you wouldn’t have done it that way. You realize that if the code had been structured differently, modifying it would be far easier. After a few failed attempts to fix the code yourself, you give up—it feels like it will take more time to fix than to rewrite. Or perhaps to re-prompt? Yes, at least start with a re-prompt for dear sake.

So you try again, this time providing a more detailed prompt. You describe not just what you want, but how you want the code structured so it can be modified later. The AI acknowledges this, promises to do better, and generates a new solution. It’s closer—so very close—but still not quite right. It does exactly what you asked, but you realize you also wanted it to do one more thing..

You dive back into the code, hopeful. This time it’s easier to navigate. You make a small tweak, but something else breaks. You trace that issue, fix it, and another dependency breaks. The “small tweak” becomes a valiant effort to salvage the solution. Eventually, frustration sets in and you give up again!

Another re-prompt? It was so close. Maybe adding one more nuance will finally get it right. You try again. A new solution is generated. You test it… and… and… and perhaps at this point, a cup of tea is exactly what you need. It’s not quite there yet!

Coding with AI is now part of how we work, but it is not without frustration. Even when AI gets things mostly right, there’s a lingering sense that you’ll pay for it later. The technical debt is real. The thought of maintaining the code can be unsettling. When it gets things wrong, the hope that a small prompt tweak will fix it fades after a few cycles, and a rewrite becomes inevitable. In hindsight, it often feels like a more cautious approach would have been wiser.

So what does being more cautious look like?

Procedural Automation

I’ve been developing software for over 30 years, and the coding experience has improved dramatically over that time. IDEs that structure code for readability, enforce syntax, prevent simple compiler errors, and autocomplete references have all helped us become more productive. AI takes coding automation to an entirely new level, which makes caution even more important.

Yes, AI can write entire applications from a single prompt—and that’s impressive. But if you want to understand, maintain, and evolve what’s been written, a more procedural approach works far better. Instead of starting with “Write me an app that does this…”, try breaking the problem down.

For example, begin by defining the structure of your application:

“Write a web application framework that can display content in a web page and allow me to interact with it.”

Once the framework is generated, add specific controls:

“Add a button to the interface to handle a function callback.”

Then define what that function should do, either by prompting or writing it yourself:

“Write code that takes these parameters … and outputs this …”

You can continue adding functionality step by step, prompting or coding as needed, until the solution is complete. The key difference with this approach is that you understand how the application is structured and how its functions work together. When changes are required, you know exactly where to make them and how they may impact other parts of the system.

This procedural approach to coding with AI, procedural automation, mirrors how developers have always worked—adopting new automation tools while remaining in control of the solutions they build. It enables a high level of quality to be maintained, while still delivering solutions in a fraction of the time.

Conclusion

AI offers a powerful opportunity to accelerate software development and engineer innovation. Used without caution, it can waste time, reduce quality, and increase frustration. Used procedurally, it can dramatically improve productivity while maintaining clarity, quality, and control.

Procedural automation is the antidote to slop.