Vibe Coding

In recent years, a new wave of AI driven by LLM technology has swept across the industry, quickly infiltrating the daily lives of ordinary people outside of the information technology sector. The rapid and somewhat alarming iterations of development are knocking on the doors of traditional enterprises and end-users, bringing convenience, efficiency, and enjoyment to both individual and corporate users, while also replacing some jobs and roles in various industries.

As a front-end engineer in a niche area of the computer industry, I may only be a layman compared to the algorithm engineers and mathematicians directly involved in LLM development, but I stand closer to the forefront than the general public. One aspect that cannot be overlooked when discussing how IT professionals in other specialized fields perceive and use AI is AI-assisted programming. Whether out of curiosity to try something new or due to the pressure of improving efficiency and assessments, AI-assisted programming, or Vibe Coding, has become an essential skill for computer engineers.

My Experience with Vibe Coding

I was exposed to AI-assisted programming early on—three years ago, when ChatGPT first gained popularity, I attempted to integrate AI completion and code generation into my workflow. However, at that time, the programming capabilities of AI were still lacking. The LLM’s understanding of code context and prompts was insufficient, and the generated code could not be directly used in production; AI code completion was neither fast nor accurate, which not only failed to improve my coding efficiency but sometimes even caused distractions. Therefore, during the initial wave of AI, I was quite resistant to Vibe Coding, driven by the principle of accountability for output and a distrust in AI’s efficiency.

The rapid development of computer science and industrial technology is evident, especially in LLMs. In just two to three years, the usability of AIGC has skyrocketed. Generated photos and videos have evolved from early “scribbles” to nearly indistinguishable from reality, and creative artwork has progressed from poor doodles to a level that threatens professional illustrators’ livelihoods—naturally, the ability to generate code has also undergone a dramatic transformation. With longer context windows and more precise instruction-following capabilities, Vibe Coding can now fully meet production needs.

Developers are sensitive to changes and improvements in technology. Noticing the rapid growth of AI-assisted programming capabilities, I tried to reintroduce AI as my coding assistant. Meanwhile, as a tech giant, my company is also very perceptive, providing us with abundant AI resources and encouraging us to use AI to enhance our development work. Now, I have gradually integrated Vibe Coding into all my projects—old projects maintain a relatively conservative pace, progressively introducing AI code generation and AI-driven testing; new projects are more aggressive, almost entirely delegating business logic code generation and testing to AI, creating “AI-native applications” with almost no handwritten code.

Ten Core Techniques for Generating High-Quality Code with Vibe Coding

Here are some thoughts and experiences from my Vibe Coding practice that may provide valuable insights for you as you read this article.

1. Use AI IDEs Instead of AI Plugins

During the Vibe Coding process, it is recommended to use AI IDEs rather than traditional IDEs with AI-assisted plugins—even if the AI IDE’s vendor also offers a plugin version.

AI-assisted plugins can utilize the same large models as AI IDEs to achieve similar programming levels and reasoning capabilities. However, AI-native IDEs designed specifically for Vibe Coding typically have higher permissions for file and directory operations. This means that AI IDEs are better at reading the overall context of the project and handling files and code than plugins.

2. Choose the Right LLM Model

As of now (the end of 2025), mainstream LLMs have impressive programming capabilities; however, selecting the most suitable LLM model remains a crucial part of the Vibe Coding process.

On one hand, while various large models perform well, there are distinctions among them. Some models excel in programming capabilities, while others consider edge cases more thoroughly, and some offer better user experience and interaction. You need to choose the most powerful model that fits your specific use case.

On the other hand, data security and compliance requirements must also be considered. If it’s a personal project or you have decision-making authority over your team’s technology, you need to consider the data policies and regulations associated with using overseas large models. If user data is involved, be cautious about the risks of cross-border data transmission. For enterprise projects, your choice of AI assistant must also comply with your company’s or team’s data security requirements, such as using self-developed large models or privately deployed ones.

3. Understand the Essence of Programming

Readers at this point are likely to be IT professionals—at least, learners with some expertise. You may have been on the path of computer science and information technology for a long time; however, I believe that no matter how long or far you have traveled, you should not forget the fundamental question of this discipline and industry: what is the essence of a program?

Due to differences in specialized fields and the resulting knowledge systems, everyone may provide different answers. However, I believe that this definition should resonate with most peers: A program, from the simplest function to complex industrial software with hundreds of thousands or millions of lines of code, can be abstractly defined as: an input, executing a series of predefined behaviors, resulting in an output.

You can recall every line of code you have written, every method, and every project you have participated in, and consider whether they conform to this definition from micro to macro.

Thus, when we use AI-assisted programming, we essentially allow a powerful black-box program (the LLM) to write countless small programs (statements and functions that achieve single functionalities) for us based on natural language input, which are then combined into complex programs (pages or functional modules) and ultimately integrated into large programs (the entire project). Therefore, what we need to do is specify to the LLM what kind of input our program will have, what processing it needs to undergo, and what output we expect. By defining the input, output, and intermediate behaviors, we can clearly define a program. By providing this as a prompt to the large model, we can obtain the expected code.

4. Provide Detailed Descriptions and Instructions

In the previous section, I mentioned the basic paradigm I use in Vibe Coding: defining the code I need to generate using input, output, and behavior as three elements and providing this as a prompt to the large model. However, if you immediately put this method into practice, the output may not be satisfactory—while the generated code might run, it may not fully align with your expectations. In such cases, using more detailed descriptions and instructions to form the prompt can significantly improve the situation.

For example, if you simply prompt, “Generate a method that takes an array, sorts it quickly, and outputs it,” the AI may produce something, but it is likely not to meet your needs. If your prompt is, “Help me generate a method that takes a number-type array, sorts it in ascending order without altering the original array, and outputs a new array,” the usability of the generated result will be much higher.

Similarly, asking, “Help me generate an image carousel component,” may yield a barely usable image carousel; however, asking for, “Help me implement a carousel component that can control size via CSS, with images filling the space using the cover method, and supports passing custom CSS for indicators and navigators, with an option to control visibility through parameters,"—while verbose—will provide a highly usable carousel component.

Regardless of parameter types or user behaviors, function logic, or overall module functionality, the abstract concepts of ‘input,’ ‘behavior,’ and ‘output’ should be defined and detailed as much as possible. By providing detailed descriptions of input, output, and behavior, the LLM can better “understand” your intent and generate code that closely aligns with your expectations.

5. Break Down Tasks and Use Step-by-Step Approaches

If you have started to incorporate Vibe Coding into your interest projects or work practices to complete simple tasks and wish to increase the AI’s role in your workflow, consider how you, as a developer, completed large requirements before the era of AI-assisted programming:

First, your product manager would explain the requirements, describing what they hope you will implement; after understanding the requirements, you would break down the specific, contextual needs into abstract, modular tasks; ultimately, you would translate these tasks into detailed atomic steps and lines of code.

You may have realized that task breakdown and step-by-step approaches play a crucial role in traditional programming paradigms; in Vibe Coding, this is also a very practical technique. Asking, “Help me generate a calculator” is a simple and effective prompt, but if you want precise control over the generated outcome, asking, “Help me generate a calculator: you need to implement a string processing program that parses user input expressed as a string into recognizable numbers and operators; you also need an expression execution program that calculates the expression to obtain the result or throws an exception for invalid input,"—this modular, behavior and functionality-oriented prompt will yield better results. If you further specify, “The first step of the string processing program is to handle characters in the string using LIFO, generating an AST with numbers as leaf nodes and operators as internal nodes; the second step is to compute the AST’s leaf nodes using depth-first reduction until only the root node remains, which is the calculation result,"—this detailed breakdown will lead to AI-generated code that aligns more closely with your vision.

6. Use Reference Code to Maintain Good Coding Style

If you use Vibe Coding frequently, you may have noticed that while AI-generated code is of good quality within a single conversation or file, expanding the observation to multiple rounds of dialogue or several files may reveal inconsistencies in style. Many people complain that “AI cannot match human engineers,” believing that “AI is just generating new messes every day”; however, providing appropriate references can effectively resolve this issue.

To enhance existing projects, before allowing AI to develop new features or pages, you can include previously written similar code files in the prompt and ask the LLM to mimic its coding style and implementation approach. If you are starting a new project from scratch and want the AI to maintain stable coding style and quality, you can include Lint standards in your prompt.

The LLM is a mysterious black box, and the code it generates has uncertainty; however, we can improve the determinacy of results by providing reference code and standards, striving to maintain good coding style.

7. Use Reference Documentation for Faster and More Stable AI Performance

In the previous section, we discussed using reference code to optimize AI coding style; now, let’s look at another type of reference—reference documentation plays a more significant role in the Vibe Coding workflow. This reference documentation includes type definitions, technical solution descriptions, and algorithm descriptions, among other technical documents.

To output high-quality code from the LLM, one best practice is to define “input,” “behavior,” and “output,” as discussed in detail earlier. So how can we best achieve this definition in the prompt? Using reference documentation can be an effective and clever approach. Instead of elaborately describing input parameters and output return types in the prompt, a simple TypeScript definition or even a proto specification can be more precise; rather than inputting lengthy descriptions of your ideas and plans in the narrow prompt dialogue box, attaching a technical solution description can be effective; if you want the LLM to help you implement a newly proposed algorithm, providing the algorithm paper is a good idea. Incorporating reference documentation into your prompt can make your AI programming experience more concise and elegant, even turning “cannot” into “can.”

Of course, it is essential to remind that the use of reference documentation must also comply with security and compliance requirements. For non-self-developed or non-privately deployed LLMs, careful evaluation is needed to determine which documents can be fed to it and which cannot.

8. Cleverly Use Multimodal Inputs

In the realm of large models, “multimodal” is no longer a novel concept. Especially in consumer applications, various image and video generation tools have made multimodal outputs quite popular. However, you may not have noticed that LLMs optimized for programming scenarios also possess multimodal input capabilities, which can further expand their capability boundaries.

In the previous section, we mentioned that reference documentation can be an essential part of the prompt; what if your reference documentation is not pure text, but a flowchart? Simply utilize the multimodal input capabilities and directly provide the flowchart to the LLM. Many LLM models can understand processes represented in images, such as flowcharts or algorithm design diagrams, so you can input reference documentation in non-text formats.

Another important role of multimodal input in Vibe Coding is the implementation and restoration of UI. There was a time when generating code from images was a hot topic in the pre-LLM era; now, with highly developed LLMs, you can directly provide design drafts to the AI to generate style and layout code. The generated code still requires manual modifications and adjustments, but in my experience, its accuracy, compatibility, and reasonableness are comparable to traditional image-to-code solutions.

9. Maintain Continuous Context Whenever Possible

If you have started using Vibe Coding, you should be aware of what a context window is and its significance, so I won’t elaborate further. However, there is a very evident and commonly followed technique that I believe is so important that it deserves reiteration: whenever possible, maintain a continuous context.

In Vibe Coding, if the LLM is asked to generate complex, multi-file shared, or potentially globally impactful code, it will organize and analyze the entire project, storing the necessary knowledge in the context window; the code generated by the LLM, the reasoning it follows, or the prompts are also stored in the context window for future use. The context window can be seen as the “memory” of your dialogue with the LLM during the Vibe Coding process.

If you create new dialogues or clear the context arbitrarily, it can be understood as “erasing” the LLM’s memory regarding this project and the code it has read or written. While this is not a substantial destruction in the absolute sense, it will negatively impact overall efficiency and progress as you must have the large model reacquaint itself with your project, or even re-understand the code it has generated.

10. Don’t Hesitate to Start Over When You Discover a Wrong Direction

This technique contradicts the previous section’s description. Yes, in some necessary scenarios, starting a new dialogue and restarting the context window can be beneficial.

Sometimes, the LLM does not fully understand your intent, and the code it writes diverges significantly from your expectations. You may have tried correcting it with little success; you may have rolled back several statements to have it rethink, but still not achieved satisfactory results. In such cases, starting a new conversation becomes a viable option. Because, in the previous conversation, you did not know at which step the LLM’s probability chain and thought process went wrong; retracing step by step is inefficient and uncertain. During the rollback process, you also need to worry about how to handle the code generated in those steps. In this situation, it is better to start a new conversation and allow the LLM to “clear its memory” and rethink.

Of course, specific operations still need strategy. For instance, during the Vibe Coding process for the entire project, your initial conversation is A; at some point, you want the LLM to help you implement requirement X but find that the output does not meet expectations and cannot be improved. In this case, you start conversation B and successfully resolve requirement X; then:

If requirement X is a small function or module with limited impact and low coupling with other parts, you should return to conversation A to continue your work. At this point, conversation A retains the complete context from before, and you only need to read a small segment of code generated in conversation B to enhance its “temporary knowledge base.”

If requirement X involves a disruptive restructuring or a significant modification, you can abandon conversation A and continue in conversation B. Because after a disruptive restructuring, much of the knowledge retained in conversation A’s context is outdated, requiring a rebuild of the “temporary knowledge base,” which incurs costs similar to reacquainting with the entire project in conversation B.

Maintaining caution and striving to keep the context window continuous is necessary; however, at the right moment, not hesitating to start over can help you resolve many issues.

The Value of Human Engineers in the Era of Vibe Coding

As the coding capabilities of LLMs continue to improve, their involvement in our daily work is increasing. While we enjoy the rapid efficiency brought by these tools, we also inevitably feel the threat of being replaced by them. So, in this era where Vibe Coding is becoming mainstream, what is the value of front-end engineers—or, more broadly, traditional business development engineers?

Human Code Review is Still Necessary

Theoretically, at this stage and for the foreseeable future, regardless of how advanced artificial intelligence becomes, its foundation remains a probabilistic model—in other words, the outputs of LLMs are not based on rational thinking but rather on probabilistic guesses. While LLMs may achieve higher coding efficiency and lower error rates in actual testing results, and may even provide reasonable and detailed reasoning in their outputs, their essence remains a probabilistic black box, which is still unreasonable compared to humans.

In Vibe Coding practice, even when using the most advanced models and providing the most detailed optimizations and corrections, human engineers’ involvement remains indispensable.

Whether it’s the theoretical pursuit of determinacy or the practical need for quality assurance, manual code review and the work of human engineers remain essential components.

Moving Forward: The Importance of Product Thinking is Increasing

The emergence of Vibe Coding has made the specific implementation of code less critical. The key step has shifted to abstracting specific requirements and converting them into detailed, precise, and implementable prompts for AI.

Previously, developers were responsible for the entire process of converting product requirements into code; however, with AI taking over the specific coding tasks, developers need to step forward: using deeper product insights and the professional knowledge accumulated throughout their careers to bridge the gap between product requirements and LLMs. As AI still struggles to understand products, developers with product thinking will become key players in realizing requirements in Vibe Coding.

Digging Deeper: Architectural Skills are Becoming More Critical

Breaking down large requirements into modules and segmenting complex methods are also assessments of developers’ architectural skills. A harsh reality is that junior programmers who can only write code without architectural skills will indeed be replaced by AI—if they haven’t been replaced yet, it may just be because AI is not yet affordable. However, engineers with architectural skills will continue to maintain their professional viability.

In a broader context, the ability to implement complex but classic algorithms with code is becoming less important—perhaps a reference for assessing an engineer’s knowledge base but lacking practical business value. Instead, the ability to determine which foundational architecture to use for different requirements, how to organize data, which methods to employ to withstand high concurrency, and what strategies to maintain robustness will become the new core competencies built on knowledge and experience.

Keep Learning and Stay Technically Aware

We must not overlook that, aside from AI, other specialized technical fields are also continuously advancing; as we gradually adapt to Vibe Coding, we cannot become complacent in learning new knowledge or let our technical awareness dull.

If you are a front-end engineer, are you familiar with the new ECMA Script standards released each year? Are there new tricks in the CSS standards committee’s new drafts that can create visually appealing effects? For back-end engineers, are you keeping an eye on the latest developments in Kubernetes? Are there new solutions for distributed architectures facing massive data and traffic? For client-side engineers, are you aware of the latest security enhancements and API restrictions in the newest Android versions? Have you understood the new features in iOS?

Continuously learning and keeping up with the latest professional knowledge in your specialized field will always yield benefits.

After all, LLMs have knowledge cut-off dates, while we human engineers can continuously learn new knowledge; if our “knowledge base” falls behind that of LLMs, we risk being completely replaced.