With the development of AI technology, those who use AI tools like Codex, Claude Code, etc., have seen their productivity increase tenfold or even a hundredfold. For technical users, as long as they can write prompts, troubleshoot, iterate, and develop skills, AI can indeed become a high-leverage production tool.
However, for non-technical OPs, small and medium-sized enterprises, or business operations, AI is currently still not very comfortable to use:
If they start using it directly, they need to spend a lot of time learning and troubleshooting. Different models have different capability boundaries, prompt writing is different, and the failure results need to be troubleshooted by themselves. Developing a useful skill itself has a fairly high threshold. Meanwhile, the best practices of Vibe Coding often conflict with many users' usage habits. Many people prefer to write all requirements at once and hope that AI can directly provide a satisfactory result, but this is often not achievable. In most cases, a truly effective AI workflow requires multiple rounds of dialogue, continuous prompting, testing, and modification before it can approach the desired result.
If hiring someone to use it, it is usually difficult to find good people, plus there isn't that much stable workload, and it incurs additional salary costs. Finding an employee who is proactive and adept at using AI is not easy; most employees have a passive mindset, working simply to earn their salaries, and even communicating may not be as efficient as directly using AI. The result could be that money is invested in AI, but costs are not genuinely saved, and it may even be less efficient than not hiring at all.
Will this dilemma disappear as the capabilities of AI's underlying large models improve? Currently, it seems unlikely.
The existence of skills itself proves that the direct output of large models often cannot meet specific needs, and improvement requires predetermined skills to enhance results. Even if in the future AI becomes as smart as humans, this issue will still exist. Because in reality, unless a certain degree of standardization is achieved, clearly communicating requirements with others and getting the desired results in one go is inherently a difficult task.
Therefore, it can be seen that individuals who do not know how to use AI and those who are proficient in AI will have an increasingly widening productivity gap in an era of rapid AI advancement, which is also a real background for the "AI anxiety" many people experience. It seems we are always learning how to use AI effectively, but the emergence of new things is too rapid and abundant, and it feels like it can never be fully learned.
The xBubble launched by DAPPOS targets precisely this area. Its approach is not to require every user to become an AI expert or to learn Vibe Coding, but to implement a Vibe Coder encapsulation for certain problems through an SOP system, helping those without a technical background in small and medium-sized enterprises or individuals to use AI without needing to spend time on learning and troubleshooting, nor needing to hire additional personnel.
xBubble Architecture
The SOP is the solution xBubble uses AI to resolve specific issues.It is not just an individual skill, nor a longer prompt, but packages together skills, runtime environment, model selection, MCP, and third-party APIs to achieve relatively stable performance for specific domain problems.
Around SOP, the product architecture of xBubble can be divided into two systems: Bubble Engine and Bubble Pilot.
Bubble Engine is the solution generation layer. It is responsible for generating and training the SOP, building solutions for specific tasks through an AI coding agent, and continuously adjusting the results through testing, evaluation, and iteration to better meet the needs.
Bubble Pilot is the runtime distribution layer. It reads user requests, identifies task types, and then finds the most matching scheme from the SOP library to execute. If there is no suitable dedicated SOP, it can fall back to a more general scheme, such as Computer SOP.
SOP is positioned in between the two. The Engine is responsible for creating SOPs, while the Pilot is responsible for dispatching SOPs.
In this way, users are not faced with a whole set of complex AI toolchains, but rather a more accessible entry point to “state the task and receive the results.” Model selection, runtime environment, skill invocation, API configuration, and iteration logic are all placed on the system side as much as possible.
What is SOP
In xBubble:
SOP = Skills + runtime + APIs + MCPs + Model Selection
A skill alone cannot guarantee stable results. Actual outputs also depend on what model is used, what environment it runs in, whether the necessary APIs are integrated, whether there are suitable MCPs, and how anomalies and iterations are handled during execution.
If all these are left to user configuration, the threshold for use remains very high. xBubble's approach is to encapsulate these variables into SOPs together. Users do not need to individually select models, configure APIs, or repeatedly test among similar skills, but rather directly trigger corresponding solution paths based on task descriptions.
Compared to the conventional skill market, xBubble's SOP system mainly has three aspects of advantage:
1. Stable Performance
Since SOP not only includes skills but also encapsulates the runtime environment, model selection, MCPs, and third-party APIs, it effectively eliminates many uncertainties during the execution process, resulting in more stable outcomes. Additionally, SOPs are only used to complete problems within a verified scope and are tested within this scope. Therefore, when the task fits within the SOP description scope, the results are typically quite stable.
This is different from the logic of open-source skills. Open-source skills often pursue more stars, typically making them more generic. While generality is beneficial, the cost is that many skills are not well tested beyond examples, and there are many functionally similar skills. As a result, users still need to spend time testing, comparing, and verifying to determine whether a particular skill can meet their needs. This task itself is essentially the work of a Vibe Coder.
xBubble's SOP places more emphasis on a verified applicable range. It does not mean that a SOP can do anything but aims to make the results stable within the defined and tested range.
2. Simple and Easy to Use
SOP takes the user’s task description as the main input. Users do not need to select models, manually configure or pay for third-party APIs, let alone understand which skill is being called in the background.
Bubble Pilot will determine the task type based on user requirements and prioritize recommending more specialized SOPs. Since SOPs have already undergone testing and verification within a certain scope, users typically do not need to compare multiple SOPs repeatedly. If a dedicated SOP already covers the task, it will be prioritized for use. If the results are still not ideal, they can also continue to iteratively optimize through the services of Bubble Engine (submitting "Bubble Up").
In other words, what xBubble aims to solve is not whether "AI can do it," but whether "ordinary users can cost-effectively and reliably let AI do it." The prompt debugging, model selection, API configuration, and result iteration that users originally needed to undertake have been as much as possible transferred to the system side.
3. Self-Generated
Developing a useful skill has a certain threshold and requires time to debug and optimize. For users without a technical background, this itself is not very friendly. Meanwhile, open-source skills are often quite generic and difficult to cover more customized needs such as internal company formats, personal preferences, and industry templates.
xBubble's goal is to encapsulate the Vibe Coder. For the vast majority of demands, it does not ask users to develop and debug skills themselves, but helps users encapsulate that complexity so they can self-generate dedicated SOPs through the Bubble Engine.
At the same time, the applicable scope of SOP can vary widely. For example, in Work mode, if no dedicated SOP can handle a certain type of task, the system will typically use Bubble Computer SOP to address general issues. However, if users have very specific needs, such as creating PPTs according to their company's template specifications, generating documents in a fixed format, or producing content in a specific internal style, it can also generate SOPs that apply only to certain users or companies.
This is also one of the distinctions between the SOP system and the typical skill market. It does not only provide a set of general components for users to choose from but allows users to generate more specific solutions around their task boundaries.
How SOP is Trained
In xBubble, the SOP is trained using Bubble Engine, with the goal of replacing Vibe Coder and directly generating SOPs that meet user needs. Mechanically, SOP can be seen as a function that maps specific prompts to results. Therefore, the issues to be solved in performance tuning can be simplified and described as:
Max Rank(SOP(prompt))
This means that after a user requirement is processed by SOP, the generated result should be ranked as high as possible in the evaluation system, approaching the output the user truly wants.
Training Cases
The training of SOP revolves around cases.
Users can directly send examples they believe meet the requirements, such as suggesting a reference to a company's video advertisement or sending results they have previously completed manually. This case can be a document, PPT, advertisement video, web style, or any output style that they hope the system can emulate.
If there are no relevant cases in the training task, the Bubble Engine can also automatically search for reference materials online or use results generated by other AI products as training cases.
After confirming the cases, the system will reverse deduce prompts based on the original problems and the complexity of user input, forming groups of (prompt, result) combinations. These combinations will serve as the foundation for subsequent SOP generation and evaluation.
The key to training is not simply copying cases, but finding the right way to generate results similar to case outcomes based on prompts, without mixing in result information during the development process. Otherwise, the system can easily perform well only on training cases and fail on any similar task.
Iterative Cycle
Next, Bubble Engine will develop new dedicated SOPs based on coding agents and some benchmark SOPs.
To avoid overfitting, the development process will also refrain from directly mixing specific result information into the SOP. Otherwise, it may seem that the training results are excellent, but the actual use may have very poor generalization capability.
Once development is complete, the system will run the new SOP to produce test results and evaluate them, summarizing the existing issues.
The evaluation mainly consists of two aspects:
Determining through AI whether the results meet the requirements prompted by the user in the training tasks. For example, whether the format is correct, whether the content is complete, and whether it meets the explicit limitations set by the user.
Determining if the result is sufficiently close to the cases. For example, style, structure, content organization, and output form—all aspects close to the reference results provided by the user.
Based on the evaluation results, the coding agent will continue to modify the SOP, regenerate, re-evaluate, and revise. This process will continue until results can no longer be significantly improved.
This set of processes essentially automates what was originally done manually by the Vibe Coder: reviewing cases, writing plans, running results, identifying issues, modifying plans, and iterating repeatedly.
Scope Definition
Completed performance-tuned SOPs need to have their applicable scope defined before being integrated into the system.
This step is crucial. Because dedicated SOPs are not necessarily better in greater numbers, and it is not always appropriate to prioritize recommending them. If a SOP is only effective in a very narrow task yet is used to handle broader issues, it may be less effective than a general SOP.
The Bubble Engine will determine which tasks this SOP is suitable for and which it is not by testing different cases and analyzing the content of skills within the SOP.
The goal of this phase is to ensure that Bubble Pilot only recommends dedicated SOPs when their performance is better than general SOPs. Otherwise, the system will revert to more general solutions.
Professional Solutions
For particularly complex SOP generation—for example, tasks requiring third-party paid APIs, or tasks for which the current large model performance is insufficient for fully automated completion—xBubble also offers manually assisted professional solutions to cover the customized needs of enterprise users.
This type of manual assistance serves as a transitional layer between current model capabilities and enterprise needs. As foundational AI models continue to improve, the cases requiring manual assistance will rapidly decrease.
Interpretation Summary
From a product logic perspective, the xBubble SOP system is not just another ordinary skill market, nor is it a simple aggregation of several AI tools. Instead, it productizes the act of Vibe Coding itself.
The skill market addresses the question of "which skills to choose," but for non-technical users, the more difficult part often lies in the latter segment: which skill suits my scenario, what model should be configured, how to run it, what to do if the results are unstable, whether it can be reused next time, and what to do if open-source skills are not usable.
What SOP seeks to address are precisely these issues. It aims to move the tasks of selecting, configuring, testing, developing, defining scope, and iterating—traditionally the work of a Vibe coder—onto the system side, while the user only needs to describe the task.
Of course, how far this system can ultimately go still depends on two variables: one is whether the quality of SOPs generated by the Bubble Engine is stable enough; the other is whether the speed of SOP coverage can keep pace with changes in user demands and general agent capabilities.
But at least at this stage, for individuals without a technical background and small and medium-sized enterprises, xBubble provides a different path: instead of first learning the complete AI toolchain and then attempting to use AI; it directly encapsulates cutting-edge AI productivity into reusable workflows through task-level SOPs.
Users just clarify their goals, and xBubble handles the AI operations behind the scenes.
About DAPPOS
DAPPOS is an artificial intelligence company focused on low-threshold AI products, building easier-to-use AI workflows for both ordinary and professional users. DAPPOS has completed over $20 million in funding, with investors including Polychain, Binance Labs, Sequoia China, IDG Capital, OKX Ventures, and others.
About xBubble
xBubble is a low-prompt AI Agent product launched by DAPPOS, aimed at helping users complete tasks like documents, PPTs, websites, images, videos, surveys, automation, and scheduled tasks with shorter requirement descriptions.
xBubble packages cutting-edge AI productivity with lower learning costs into a format accessible to ordinary users, enabling them to achieve professional-level AI productivity without needing to learn the complete AI toolchain.
免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。
