December marks a turning point as product revenues reach a significant level, validating those speculations. At this moment, the focus shifts not toward future visions but rather to Chairman Mao’s old saying: “A spark can start a prairie fire.” It’s as if numerous sparks have been spotted, flickering subtly in layers not easily visible.
Why AI is Still Not Ready!
It may seem contradictory, but it’s the dual perspective needed for a comprehensive evaluation.
Certainly, an AI-native application wave is imminent. Previous articles predominantly discussed the interpretation of Turing Test 2.0 and defining what intelligent native should look like. This time, let’s take a different approach by presenting a concrete and real example from a community called “Zhuo Mo Shi.”
The background is straightforward: Zhuo Mo Shi has a reader group with no specific commercial purpose, gathering individuals interested in AI for casual discussions on topics such as viewpoints in articles and industry trends. Members are professionals with thoughts on AI.
Then something interesting happened.
At some point, the group attracted some peculiar individuals.
As the group owner, I usually glance through forwarded articles and such. After a while, I noticed a few members who seemed off. They irregularly posted articles with catchy titles but sparse and short content, always accompanied by ads. Strangely, they remained silent, never engaging in conversations.
This group allows free speech as long as it’s not offensive, so initially, I paid little attention.
But then, in a moment of realization, I understood that these were not real people; they were likely bots.
Looking back, it became clear that although their tactics seemed unscrupulous, it was indeed a small-scale AI-native application. Pure-blooded
Let’s imagine the structure behind it.
There must be a perceptual part linking to the real world to capture hot topics and select corresponding topics. Then, generate content based on the chosen topics. Simultaneously, use a crawler to join relevant groups for feedback. Given that joining groups with less than 200 members is easy through QR codes, these groups are likely the primary targets.
Furthermore, identify the attributes of the corresponding group and match them with the content. Finally, implement periodic, irregular postings.
This application involves three core parts: scheduling large models to scan and generate content, daily tasks such as posting principles, and alignment with the real world.
Perceiving reality, producing content based on large models, and embedding profit elements during browsing – a typical new-age intelligent native application. It’s hard to imagine such a form emerging.
The above example aligns perfectly with the previously mentioned agent structure, about 80% similar.
Different from Past Applications
From a technical perspective, based on previous technology, it’s not entirely impossible to achieve this without large models, especially for those familiar with web crawling. However, in the past, making money with such an approach was challenging. (Even now, it’s uncertain whether this approach is profitable; I’d like to ask those guys to harass me for several days.)
The reason is simple: when AI is not mature enough, generating numerous subscription articles, especially ones matching real-time trends, is difficult.
So, this application is genuinely a new category (also known as an agent). It is a closed-loop scenario from perception to production to profit.
From the perspective of intelligent natives, this is not an AIGC tool.
Intelligent Native Applications vs. AIGC Tools
Although both claim to be AI-driven, there is a fundamental difference.
AIGC tools are essentially algorithm-driven and are only feasible under specific conditions. Their business models are extremely challenging to establish.
The key to intelligent native applications lies in their application, combining technology into product power, breaking the final 1-millimeter barrier. Most people can create and generate cash flow. We are familiar with this; it’s similar to the situation when mobile apps emerged.
In the past, the British invented the tank during World War I, but the true magnificence of tanks awaited the German’s Blitzkrieg tactics.
The difference between AIGC tools and intelligent native applications is similar to this analogy.
AIGC tools are like tanks, while each intelligent native application is a unique battle.
For AIGC tools, the uniqueness of the model is crucial. For intelligent native applications, a deep understanding of the model might be detrimental, and it’s more essential to look outward, positioning precisely at the intersection of technology and scenarios.
By the way, intelligent native applications are not GPTs.
Including GPTs, chatGPT itself is, in fact, a super-intelligent native application, covering the most general scenarios.
This is the vast space implied by intelligent native applications.
Almost every field will witness these more intelligent and automated intelligent native applications.
So, the various attempts that are just emerging now are the sparks.
And with the continuous improvement of large model capabilities, the sparks will only get larger, covering a broader range.
It will expand from the extremely boring scenario mentioned above to various aspects. The current situation is roughly equivalent to Windows applications in 1995 and mobile internet in 2007.
Doing this is still challenging, but it can be done.
For intelligent native applications, the first key is the Turing Test 2.0.
Although it has been mentioned several times before, it needs to be emphasized because it is like the string of a kite, determining the scale – not too close or too far.
What is an intelligent native application and Turing Test 2.0?
An intelligent native application cannot stay still because it didn’t exist in the past. Without drifting, it’s impossible to imagine what the product should be defined as.
However, drifting too far is also not acceptable. It’s like initially wanting to open a restaurant, then realizing the road is not suitable, deciding to build the road first and then open the restaurant. (Most people doing intelligent native applications are more like the restaurant owner, while entities like OpenAI are the ones building the road.)
Thus, an intermediate scale is needed.
This scale determines success or failure, ranking as the top priority.
The first decision determines if it works in a specific time frame, and the second determines how extensive the mine is.
Returning to the previous example, that scenario can indeed pass the Turing Test 2.0, and the size of the mine depends on the quality of content generation.
Let’s redefine Turing Test 2.0 from the application perspective.
Turing Test 2.0
The original Turing Test is as follows:
This is a pure intelligence test, essentially pursuing logical consistency within a closed system.
Now, let’s introduce the concept of an agent into this test:
This is Turing Test 2.0. What is the core difference compared to 1.0?
Escape from illusion, with boundaries.
1.0 is a lofty system, where the illusion of rationality helps pass the test. However, 2.0 is different; the tester receives feedback simultaneously from the real scenario and the entity being tested. Moreover, 2.0 requires a higher level of intelligence depth in testing boundary constraints, similar to mastering military strategy eloquently without necessarily being effective in battle.
Returning to the earlier example, the commonality between 1.0 and 2.0 is that the generated content must be readable. What makes 2.0 unique is that the content must align with basic facts and possess some distinctive style, as the audience reads other articles besides yours. Pure nonsense advertisements likely have a lower click-through rate.
If pure nonsense is considered a person from a technical perspective, it may pass the 1.0 test. However, from a business perspective, it’s not as valuable, and the conversion rate is lower.
Implementing It for Oneself
The ability to pass Turing Test 2.0 and AIGC capabilities are indeed a perfect match.
The former defines the value of technology in a business scenario, while the latter reduces the cost of implementing it.
From this perspective, technology predetermines its implementation, creating an inevitability, an intriguing aspect whether interpreted from a causal or accidental perspective.
Conclusion
Even with the right direction and capability, implementation is challenging and feels like running in a no-man’s land. Yet, this is where the value lies. When all implicit knowledge becomes explicit, most commercial value disappears, turning into a game of skill, which becomes uninteresting
