During the Chinese New Year, I successfully deployed my personal website thinkitlab.org online. A year ago, I started my first vibe coding project, Realtime-Caption, which took a full 4 months.
Although the project scopes are not comparable—the former is a website, the latter a Windows desktop application—the actual vibe coding experience was vastly different.
When working on Realtime-Caption, I first forked an open-source ASR backend project from Github and then vibe coded based on it. Back then, I felt like a porter, constantly shuttling between the web page and the editor, oscillating between bursting a blood vessel and having a heart attack, spending 80% of the time playing whack-a-mole.
This year, it took me only three weeks to build and deploy my personal website to Cloudflare, successfully enabling LLM-based automatic translation and auto-generation of SEO keywords.
Many people talk about how much smarter AI has become, but in my view, what truly speeds us up are the engineering advancements.
AI's flaws still exist, but the progress in tools increasingly constrains AI, making these flaws no longer fatal.
The Certainty of Flaws
During the development of thinkitlab.org, I confirmed a fact: AI's flaws will persist for a long time.
It will still confidently produce nonsense, still lack a sense of time, and still fail to prioritize the importance of requirements.
It will continuously generate various bugs in specific niche areas, get stuck in old problems within the same conversation, and of course, overhaul the entire framework to fix minor UI details. This is something we must accept; it won't disappear anytime soon.
But at the same time, tools are beginning to constrain models through the environment. Since it has hallucinations, the IDE provides an automatically runnable test environment that validates the code the moment it's generated. Since it lacks a sense of time, give it a file system and Git history so it knows where it is in the process. Since it can't judge the importance of requirements, force it to plan and create to-do lists.
In the past, we were always waiting for a more perfect model. Now I understand that for a long time to come, interaction design should be built on top of these flaws. This kind of reinforcement work is where the real application value lies.
The Certainty of Components
Through this short three-week development cycle, I found that the core components of a useful AI application have become very certain.
First is information organization capability. The quality of problems AI can solve is highly dependent on the quality of information it receives. We need to provide information to the model on demand, or capture scattered, unstructured information, organize it structurally, and then feed it to the model.
During development, the IDE doesn't send all project information to the LLM at once. Instead, it first searches the directory, locates specific files, reads the code in those files, and extracts code snippets based on requirements.
Only by achieving automated information orchestration for specific scenarios and needs can we truly solve each person's personalized problems.
Second is memory management capability. The IDE can perceive the overall architecture of the entire project. It remembers previous modification logic and knows the dependencies between different files.
By establishing a complete code index and association mapping, it forces the model to remember previous modification logic and the dependencies between different files.
For example, Google's Antigravity lists a complete walkthrough, combined with to-do lists to form comprehensive project management, keeping the AI constrained within a limited requirement framework.
This kind of "external memory" and framework constraints provided by tools ensure that AI won't go astray in complex projects due to forgetting context.
Finally is frontend rendering capability. This is what impressed me the most this time. We can't keep communicating with AI solely through text; the interaction burden is too heavy.
During development, the IDE uses GenUI technology to directly render a preview interface. Going a step further, it integrates browser-use capabilities to simulate actual user operations in the background for testing. This capability hides obscure code logic behind the scenes, delivering deterministic visual results and operational feedback, allowing us to reverse-validate AI's logic by observing its real-time running state.
This kind of instant rendering and automated verification is the core guarantee for efficiency improvement.
The Certainty of Unconscious Automated Execution
The recent popularity of projects like OpenClaw stems from their validation of another certainty: unconscious automated execution.
We don't need to, and shouldn't, become experts in asking questions. After all, the ability to fully describe a fact is a scarce resource. For the vast majority of people, the burden of asking questions is too heavy.
OpenClaw's success lies in demonstrating the possibility of "bootstrapping." It has a real-time feedback mechanism based on environmental awareness. Once a deviation or error occurs during execution, or if it detects changes in information, it can immediately and automatically adjust its strategy, achieving self-correction and response within a closed loop (even if it achieves this through constant looping queries and stacking markdown).
This kind of automated execution interaction experience is what users truly expect: an unconscious experience. We don't need to continuously monitor AI's work status, write thousands of words of complex instructions, or learn various "magic tricks." We only need to set a task goal, such as "help me manage my social media accounts," and AI can actively observe the environment, make autonomous decisions, and complete the work (even if it might delete all your email records).
This shift from "user asking questions" to "AI automatically closing the loop" has garnered so much attention, proving it is a deterministic trend in AI applications.
The changes in AI over the past year have made me realize that in the short term, intelligence improvements will hardly see a leap like from GPT-3.5 to GPT-4o. In the foreseeable future, progress will be more in engineering.
How much progress AI can make depends on how well we can leverage these deterministic tool components to mitigate known flaws.
We should amplify AI's strengths by focusing on information organization, memory management, rendering capabilities, and automated execution, creating a tightly constrained operating environment for it.
Leveraging these deterministic capabilities is the deterministic direction where product people can strive to create value.