Ten Commandments for Production-Ready Vibe Coding

This article presents over 9+ commandments for "vibe coding," aiming to elevate the practice to a production-ready standard. It's designed for a broad audience, primarily senior developers, but its principles are applicable to all levels, from those just starting to principal engineers.

What is Vibe Coding?

First, what exactly is vibe coding? This term, coined earlier this year, has quickly gained popularity. It describes the practice of coding with AI without meticulously checking every single line of code the AI generates. This is distinct from more methodical AI-assisted coding where every output is verified.

The belief is that vibe coding will mature into a production-ready methodology. This evolution will likely involve a blend of skills: casual coders may become more like senior software engineers, and conversely, senior engineers will need to adopt some vibe coding techniques. This article explores how to navigate that intersection.

The Commandments of Vibe Coding

Here are several key principles to follow for effective and safe vibe coding.

1. Don't Rely on It Too Much if You're Junior

This point is crucial. For junior developers, it's easy to make significant architectural mistakes, even if the AI handles the implementation details correctly. These fundamental errors at the start of a project can have lasting consequences.

Therefore, a different approach is needed. Use AI to ask numerous basic and fundamental questions. Seek to understand the project's purpose, its structure, and the technologies involved. This isn't about discriminating against junior developers; anyone can be "junior" in a new context. For instance, an experienced developer unfamiliar with Rust is effectively a junior in that domain and should ask questions like, "Should I use this framework versus this other framework?"

2. Learn to Break Down Large Problems

This principle was vital long before AI and remains just as applicable to vibe coding. If a project is too complex for an AI to build in a single attempt, it must be simplified. Keep breaking it down into smaller, more manageable pieces until each part is simple enough for the AI to handle effectively.

Imagine you need to get from point A (an empty state or a specific commit) to point B (a new feature, a bug fix, or a completed project). If the direct path is too difficult, you must create several intermediate steps that the AI can tackle one by one.

3. Write a Lot of Tests

As AI writes more code, it will inevitably introduce more bugs. While guardrails like CI/CD are helpful, writing comprehensive tests is one of the most effective strategies.

When you have a robust test suite, the AI knows precisely which parts of the codebase are functioning correctly. If you ask an AI to solve a problem without tests, it has a vast solution space to explore. However, with good test coverage, the AI can see which tests are already passing and immediately rule out those areas. This significantly narrows the solution space it needs to search. Even if the AI writes the tests itself, a high-level check to ensure they aren't using strange mockups is sufficient to confirm that parts of the problem space are already solved. It's a strange concept, but it works like a charm.

Code can be seen as a liability. Tests, when written well, are an asset. So why not create more assets?

4. Keep File Size Under 400 Lines

This isn't a rigid rule, but a helpful guideline. When a file grows to 600, 700, or even 1,000 lines, it becomes difficult for an AI to manage, read, and edit effectively. This is a good rule of thumb for human developers anyway, so it's a beneficial practice to maintain.

5. Organize Your Codebase Well

A well-organized codebase helps people find what they need without confusion, and the same is true for AI. If the structure is logical for humans, it will naturally be organized enough for an AI to locate the necessary files and context.

6. Move Slow to Go Fast

This principle is about management understanding the value of growing a codebase without accumulating excessive technical debt. A small amount of tech debt is unavoidable, but problems arise when management pushes the engineering team to move too fast and implement too much at once. This leads to crippling tech debt, a problem that should be avoided with or without AI.

7. Make Architectural Decisions Carefully

Many of these points are standard software engineering best practices, but they become even more critical when working with AI. AI can be a valuable partner in making architectural decisions. You can ask it questions like: - "Should I use this framework or that one?" - "What are the trade-offs between GCP and AWS?"

AI can provide a wealth of information, both historical and up-to-date, to help you make better, more informed architectural choices.

8. Provide Necessary Context

When working with a new framework or API, the AI might not have sufficient training data on the latest version. In such cases, you should provide the relevant documentation. Simply copy and paste the necessary sections to give the AI the right context. You can then instruct it, "Based on this documentation, create this feature." This approach works remarkably well.

9. Keep Provided Context to a Minimum

While providing context is important, it should only be what's relevant. The performance of AI models tends to degrade when the context is too large. Even though the latest models can handle longer contexts better, it's still a good rule of thumb to provide the minimum amount of information necessary for the task.

10. Go Agentic

AI began with simple autocomplete and Q&A, but its power multiplies when it becomes "agentic"—able to take actions on your behalf. This includes accessing URLs, searching the web, scanning your codebase, and running git commands.

A powerful, albeit slightly scary, step is to give an AI controlled access to your terminal. This allows it to run commands for you, so you only need to understand concepts rather than memorizing specific command syntax. You could simply ask it to "run a bisect for me" or "identify the issue I'm running into."

11. A Bonus: Run Multiple Agents

Looking to the future, the next step is not just running a single AI agent but running tens, hundreds, or even thousands at a time. To scale this effectively, each agent will need a containerized or VM-based development environment. This will allow the agent to not only write code but also test it, including UI testing through computer vision capabilities. Any containerization tool like Docker, Podman, Dagger, or a platform like Gitpod would be suitable.

The Power of Vibe Coding Done Right

A useful way to visualize the impact of vibe coding is to compare its use by a non-technical person versus a technical one. A non-technical user can create significant value quickly on a one-off project, but the codebase soon becomes difficult to manage.

In contrast, a technical person—someone who follows the commandments outlined in this article—can create immense value from the start and continue adding to the codebase without accumulating significant tech debt. This sustainable approach is the ultimate goal.

On Testing and AI

A common question is whether Test-Driven Development (TDD) is a good methodology for vibe coding. The answer is a resounding yes. While not always practiced personally, feedback from those who use TDD with AI agents indicates that it works exceptionally well.

Another concern is the potential over-reliance on AI if it writes both the code and the tests. It seems paradoxical to have an AI test its own code. However, it's a different way of thinking. A human developer can write their own code and then write tests for it, and the process of writing tests often improves the original code by forcing a different perspective. The same appears to be true for AI. However, this doesn't mean a completely hands-off approach. It's still important to examine the tests for flakiness or mockups that simply return true, but a line-by-line review isn't always necessary.