Throughout this past year, I have spent a significant amount of time engaged in what many people call "Vibe Coding": writing software using an Artificial Intelligence (AI) agent. Specifically, I have been working to transition several of my existing Proof of Concept (PoC) codebases into robust, production-ready software. However, my approach diverges from the casual, unstructured nature of pure vibe coding. Instead, I practice a disciplined methodology that I call "Anti-Vibe Vibe Coding"—an approach focused on engineering rigor and control rather than a passive reliance on AI-generated suggestions.
Let's face it: the current version of AI consists of Retrieval and Generation (RAG) and Large-Language Models (LLMs), and they are not as intelligent as the name might suggest. I consider it "somewhat mid." At its core, it analyzes vast amounts of existing human-written content, identifies patterns, and predicts the most statistically likely output to follow a given input. In other words, it functions more like "Iterative Advanced Autocomplete" than a true reasoning engine. This works reasonably well when the subject matter is well-documented and widely discussed, but it struggles significantly when asked to reason about novel concepts or generate genuinely original ideas.
It is also the functional equivalent of an intern with a memory problem. It lacks organizational knowledge, has no awareness of your specific project context, and requires consistent supervision. Every output needs to be reviewed and verified. But perhaps more critically, it lacks a true "Do What I Mean" (DWIM) setting. When faced with an ambiguous instruction, it doesn't ask for clarification. It silently makes assumptions based on what most people have historically done in similar situations. That silent guessing can introduce subtle errors that are easy to miss, especially at scale.
The Old SDLC is now the New Hotness
After 6 months of writing and correcting AI agent code, I'm a firm believer that the SDLC, coding standards, and other software engineering processes are even more important than before AI. In the before times, sometimes you could neglect the SDLC because you had smart human developers who could extrapolate the context from what they knew about the project, the company, and their team. They could then make independent decisions and document them for everybody else.
But now with coding agents, you have to make this explicit. The SDLC provides processes, documentation, and artifacts that provide the context for AI Agents.
Build a Product Requirements Document (PRD) and an Engineering Requirements Document (ERD). A PRD defines the purpose, features, and functional requirements of the software, giving AI agents a structured reference point for every decision. Without it, agents default to assumptions that may not align with your project's goals. An Engineering Requirements Document complements the PRD by defining the technical requirements, constraints, and system specifications that developers and AI agents must adhere to. It bridges the gap between business goals and technical execution, ensuring that all engineering decisions are grounded in a clear, agreed-upon framework before a single line of code is written. Together, these documents form the foundation of any well-structured development effort.
Define detailed specifications, including a System Design Document, APIs, data schemas, and sample input artifacts. A System Design Document outlines the architecture of your application — how components interact, where data flows, and how the system scales. API specifications define the contracts between services, reducing ambiguity when AI agents generate integration code. Data schemas establish the structure, types, and constraints of your data, while sample input artifacts give agents concrete examples to work from. The more precise these documents are, the more accurately AI agents can produce reliable, production-ready code.
Use Test-Driven Development (TDD). Begin by creating test data, use AI to generate test cases, validate them, and then use those as context for development. TDD is a discipline that becomes even more valuable in an AI-assisted development environment. By defining what success looks like before writing implementation code, you give AI agents a measurable target to work toward. Start by assembling representative test data that reflects real-world inputs and edge cases. Use AI to generate a comprehensive suite of test cases based on your requirements, then review and validate those tests to ensure they accurately capture the intended behavior. Once confirmed, these test cases become critical context for the AI during development, anchoring its output to verified expectations and reducing the likelihood of silent errors slipping through.
Incorporate Security Testing. Many development teams integrate security assessment tools such as SAST and DAST into their SDLC to identify and remediate vulnerabilities as early as possible. This practice can be extended to AI coding agents by building process flows that automatically route code for security assessment and remediation.
Build Modular and Atomic Code. Modular code breaks a system into discrete, self-contained components, each responsible for a single function or feature. Atomic code takes this further by ensuring that individual units of logic are as small and focused as possible. This approach is particularly well-suited to AI-assisted development because agents perform best when working within clearly defined boundaries. When tasks are scoped narrowly, the AI is less likely to introduce unintended side effects or make assumptions that conflict with other parts of the system. Modular architecture also makes it easier to test, debug, and iterate on individual components without disrupting the broader codebase.
Small Changes, Committed Frequently. Most programming teams rely on a revision control system, such as a Git server, to manage their codebase. This practice becomes especially valuable when working with an AI agent. Committing small, incremental changes frequently ensures that you maintain a clear, traceable history of modifications. If an agent moves in an unintended direction or produces output that conflicts with your goals, this trail of changes makes it straightforward to identify where things went wrong and revert to a stable state.
Code Review Standards for AI-Generated Output. Treat AI-generated code with the same rigor as human-written code. Define clear review criteria, enforce coding standards, and require human sign-off before merging any agent-produced changes into production branches. Some of this can be codified into agents.md or another instructional file.
AI Programming Agents: They're Just Like Us
While I'm very much embracing this new future that we're heading for, I've rediscovered that the old ways exist for a reason. They're there because they are effective at coordinating development across a team. After all, in an SDLC, you explicitly state the project goals, inputs, outputs, etc. And once you've gotten over the mental hurdle of an AI programmer, you'll find that the "intern with a memory problem" that is an AI programming agent also requires the structure.
