跪拜 Guibai
← Back to the summary

The Real Vibe Coding Superpower Is a Brutally Detailed Spec

I feel that, rather than studying all sorts of Vibe Coding tricks every day, it's better to first master Spec Driven Development.

Tools keep changing, but Spec Driven Development does not.

It is enough to solve the vast majority of your daily programming problems.

Why do I always advocate for Spec Driven Development?

Because it naturally aligns with how programmers work.

Before actually starting to write code, first analyze the requirements, design the solution, and think about boundary conditions — this is what a mature programmer should be doing anyway.

In the past, these thoughts might have stayed in your head or been written in a design document.

Now, this process has simply become one of refining a Spec together with AI. Constantly discussing, constantly supplementing, constantly revising. Until this Spec is sufficiently complete.

This process is, in essence, doing design.

The Specs I write together with AI are generally quite long.

Let me show you a Spec I wrote recently while handling a production bug. It totaled over seven hundred lines and more than two thousand words.

The image below is just a portion of it.

Many people might ask, why write it so long?

Because AI does not understand your business.

It doesn't know which data absolutely cannot be lost, which historical logic must be compatible, or which places can be changed and which are best left alone.

All of this, you need to tell it. So, this Spec is not written in one go.

It is the result of dozens of rounds of back-and-forth discussion between me and the AI, slowly sedimenting out.

During this time, I continuously supplement information it doesn't know, for example:

At the same time, I also explicitly tell it some constraints, for example:

Of course, the overall design plan is mostly decided by me. I will tell the AI what plan I intend to adopt, and then let it analyze:

Very often, the questions it raises indeed help me discover some details I hadn't thought of before.

And there is another very interesting thing:

The Spec that precipitates out after dozens of rounds of discussion is itself a well-formatted AI instruction.

Some people use AI by just chatting continuously. They think of a requirement and add a bit. They discover a problem and continue asking follow-ups. After dozens of rounds, the chat history gets longer and longer, and more and more chaotic.

My approach, however, is to continuously precipitate the consensus reached during the chat process back into the Spec.

What you get in the end is not a long string of chat history, but an increasingly refined Spec.

For AI, it doesn't care who wrote this content. What it cares more about is whether this input is complete, whether the structure is clear, and whether the constraints are explicit.

And a Spec that has been repeatedly polished is precisely this kind of input. It records not just the requirements, but also includes business background, design thinking, constraints, boundary scenarios, and acceptance criteria.

So, in my workflow, chatting is just the process of forming the Spec; the Spec itself is the true instruction that drives the AI's work.

Then, isn't spending so long writing a Spec a waste of time? Not at all.

The more complete the Spec, the higher the probability that the AI will write the code correctly in one go.

Some time ago, I wrote an article titled "A Postmortem of an Online Thread Pool Fault: How Four Layers of Defense Prevent Data Loss."

For that production bug, from analyzing the problem and designing the solution to finally generating the code, I completed everything centered around this Spec.

In the end, once the Spec was complete, I had the AI generate the full code in one shot. What I did was review the code and deploy it to the test environment to verify the main flow. After confirming there were no issues, I deployed it directly to production. Throughout the entire process, I did not repeatedly modify the AI-generated code.

In the AI era, what is truly worth spending time on is not writing code, but polishing the Spec until it is correct.

This is also a deeper realization I've had from using AI. Many people spend their time repeatedly modifying AI-generated code. I prefer to spend my time perfecting the Spec.

Because when the Spec is sufficiently complete, the subsequent coding phase becomes incredibly smooth instead.

Finally, I want to say that what ultimately determines the quality of AI's output depends on the quality of the information you provide to it. By continuously communicating with the AI and slowly polishing a high-quality spec, the AI, based on this spec, can produce code that meets your expectations. Efficient and high-quality.

I believe this is the greatest trick of Vibe Coding.