Interpretation of xBubble SOP: Packaging Vibe Coding for non-technical users

With the development of AI technology, the productivity of those using AI tools like Codex and Claude Code has increased tenfold or even a hundredfold. For technical users, as long as they know how to write prompts, debug, iterate, and develop Skills, AI can indeed become a high-leverage production tool.

However, for non-technical OPCs, small and medium-sized enterprises, or business operations, using AI is still quite uncomfortable:

1. If they try to use it directly, they need to spend a lot of time learning and debugging. Different models have different capabilities, prompt writing varies, and they need to troubleshoot failed results themselves. Developing a usable Skill has its own high threshold. At the same time, the best practices of Vibe Coding often conflict with many users' habits. Many people prefer to write all requirements at once, hoping AI can directly provide a satisfactory result, but this is often difficult to achieve. In most cases, a truly effective AI workflow requires multiple rounds of dialogue, continuous prompting, testing, and modification before approaching the desired result.

2. If they hire someone to use it, it is usually difficult to find the right person, and there isn't enough stable workload, plus there are additional salary costs. Finding an employee who is proactive and can effectively use AI is not easy; most employees have a passive attitude towards work and may even find it easier to communicate directly with AI. The result may be that money is spent on AI, but there is no real cost saving, and it may even be worse than not hiring anyone.

Will this dilemma disappear with the advancement of AI's underlying large model capabilities? Currently, it seems unlikely.

The existence of Skills itself proves that the direct output of large models often cannot meet specific needs and requires pre-defined Skills to improve the results. Even if AI becomes as intelligent as humans in the future, this issue will still exist. In reality, unless a certain degree of standardization is achieved, clearly communicating needs and obtaining the desired results in one go is inherently difficult.

Therefore, it is evident that those who do not know how to use AI and those who are proficient in using AI will have an increasingly large productivity gap in the rapidly advancing era of AI, which is the real background behind many people's "AI anxiety." We seem to be constantly learning how to use AI effectively, but new things are emerging too quickly, making it feel like we can never finish learning.

The xBubble launched by DAPPOS is precisely aimed at this area. Its approach does not require every user to become an AI expert or learn Vibe Coding, but instead uses an SOP system to encapsulate Vibe Coder for certain problems, helping non-technical small and medium-sized enterprises or individuals use AI without spending time learning and debugging, nor needing to hire additional staff.

Architecture of xBubble

SOP is the solution that xBubble uses AI to solve specific problems. It is not a standalone Skill or a longer prompt, but rather packages Skills, runtime environments, model selection, MCPs, and third-party APIs together 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 SOPs, building solutions for specific tasks through AI coding agents, and continuously adjusting the results through testing, evaluation, and iteration to better meet needs.

Bubble Pilot is the runtime distribution layer. It reads user requests, identifies task types, and then finds the most matching solution from the SOP library to execute. If there is no suitable dedicated SOP, it can fall back to more general solutions, such as Computer SOP.

SOP is positioned 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 straightforward entry point of "state the task, get the result." Model selection, runtime environment, Skill invocation, API configuration, and iteration logic are all handled 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. The actual output also depends on which model is used, what environment it runs in, whether necessary APIs are connected, whether there are suitable MCPs, and how exceptions and iterations are handled during execution.

If these are left for users to configure themselves, the usage threshold remains high. xBubble's approach is to encapsulate these variables into SOPs. Users do not need to select models separately, configure APIs themselves, or repeatedly test among multiple similar Skills; instead, they directly trigger the corresponding solution path based on task descriptions.

Compared to the conventional Skill market, xBubble's SOP system has three main advantages:

1. Stable Performance

Since SOPs include not only Skills but also encapsulate runtime environments, model selection, MCPs, and third-party APIs, this effectively eliminates many uncertainties during execution, producing results more stably. At the same time, SOPs are only used to complete problems within a verified scope and will be tested within that scope. Therefore, when a task falls within the SOP description range, the effects are usually quite stable.

This is different from the logic of open-source Skills. Open-source Skills often aim for more stars and tend to be more general. While generality has its benefits, the downside is that many Skills are not sufficiently tested outside of examples and there are many Skills with similar functions. The result is that 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 emphasizes the verified applicable range. It does not mean that a SOP can do everything, but rather that within the defined and tested range, it strives to produce stable results.

2. Simple and Easy to Use

SOP takes the user's task description as the main input. Users do not need to select models, configure or pay for third-party APIs, nor do they need to understand which Skill is being invoked behind the scenes.

Bubble Pilot will determine the task type based on user needs and prioritize recommending more specialized SOPs. Since SOPs have been tested and verified within a certain range, users typically do not need to repeatedly compare multiple SOPs. If a dedicated SOP already covers the task, it will be prioritized. If the results are still not ideal, users can continue to automatically iterate and optimize through the Bubble Engine service (submitting "Bubble Up").

In other words, what xBubble aims to solve is not "Can AI do it?" but rather "Can ordinary users get AI to do it at low cost and with stability?" The prompt debugging, model selection, API configuration, and result iteration that users originally needed to handle themselves have been transferred to the system side as much as possible.

3. Self-Service Generation

Developing a usable Skill has a certain threshold and requires time for debugging and optimization. For users without a technical background, this is inherently unfriendly. Moreover, open-source Skills are often too general and struggle to cover more customized needs such as internal formats, personal habits, or industry templates.

xBubble's goal is to encapsulate Vibe Coders. For the vast majority of needs, it does not require users to develop and debug Skills themselves but helps users encapsulate this complexity, allowing them to self-generate dedicated SOPs through the Bubble Engine.

At the same time, the applicable range of SOPs can be broad or narrow. For example, in Work mode, if there is no dedicated SOP to handle a certain type of task, the system will typically use the 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 certain internal style, they can also generate SOPs that only apply to a specific user or enterprise.

This is also one of the distinctions between the SOP system and the ordinary Skill market. It does not just provide a bunch of general components for users to choose from but allows users to generate more specialized solutions around their task boundaries.

How SOP is Trained

In xBubble, the Bubble Engine is used to train SOPs, aiming to replace Vibe Coders and directly generate SOPs that meet user needs. Mechanically, SOPs can be seen as functions that map specific prompts to results. Therefore, the problem to be solved in performance tuning can be simplified as:

Max Rank(SOP(prompt))

This means that for the same user need processed through SOP, the generated result should rank as high as possible in the evaluation system, getting closer to what the user truly wants.

Training Cases

SOP training revolves around cases.

Users can directly send some cases they believe meet the requirements, such as prompts that reference a certain company's video advertisement or sending results they previously completed manually. These cases can be documents, PPTs, advertisement videos, webpage styles, or any output style they hope the system will mimic.

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.

Once the cases are confirmed, the system will deduce prompts based on the original problem and the complexity of user inputs, forming sets of (prompt, result) combinations. These combinations will become the basis for subsequent SOP generation and evaluation.

The key to training is not simply copying cases but finding suitable methods to generate results close to the case results based on prompts, without mixing in result information during development. Otherwise, the system may perform well only on training cases but fail on similar tasks.

Iteration Cycle

Next, the Bubble Engine will develop new dedicated SOPs based on some benchmark SOPs through coding agents.

To avoid overfitting, the development process will also avoid directly mixing specific result information into SOPs. Otherwise, it may seem that the training results are good, but the actual usage may have poor generalization ability.

After development is complete, the system will run tests with the new SOP and evaluate the results, summarizing any existing issues.

Evaluation mainly consists of two aspects:

1. Using AI to determine whether the results meet the requirements specified by users in the training tasks. For example, whether the format is correct, whether the content is complete, and whether it meets the explicit constraints set by the user.

2. Determining whether the results are sufficiently close to the cases. For example, style, structure, content organization, and output form should be similar to the reference results provided by the user.

Based on the evaluation results, the coding agent will continue to modify the SOP, generate again, evaluate again, and modify again. This process will continue until the results can no longer be significantly improved.

This entire process essentially automates what Vibe Coders originally did manually: reviewing cases, writing plans, running results, identifying problems, modifying plans, and iterating repeatedly.

Scope Definition

Before connecting the performance-tuned SOP to the system, it is necessary to define its applicable scope.

This step is crucial. Because dedicated SOPs are not better in greater numbers, nor should they be prioritized at all times. If a SOP is only effective for a very narrow task but is used to handle broader issues, it may be worse than a general SOP.

The Bubble Engine will determine which tasks the SOP is suitable for and which it is not by testing different cases and analyzing the Skill content within the SOP.

The goal of this step is to ensure that Bubble Pilot only recommends dedicated SOPs when their performance is better than that of general SOPs. Otherwise, the system will revert to more general solutions.

Professional Solutions

For particularly complex SOP generation, such as tasks that require third-party paid APIs or tasks that current large model capabilities cannot fully automate, xBubble also provides human-assisted professional solutions to cover the customized needs of enterprise users.

This type of human assistance acts as a transitional layer between current model capabilities and enterprise needs. As underlying AI models continue to improve, the number of cases requiring human assistance will rapidly decrease.

Interpretation Summary

From a product logic perspective, the xBubble SOP system is not just creating an ordinary Skill market, nor is it simply connecting several AI tools together; rather, it is productizing the act of Vibe Coding itself.

The Skill market addresses the question of "What Skills are available?" but for non-technical users, the more challenging part is often the latter: Which Skill is suitable for my scenario? What model should be paired? How to run it? What if the results are unstable? Can it be reused next time? If open-source Skills don't work, how can I create a usable Skill?

SOP aims to solve precisely these issues. It attempts to move the tasks of selection, configuration, testing, development, scope definition, and iteration—originally the work of Vibe Coders—onto the system side. Users only need to describe the task on their end.

Of course, how far this system can go ultimately depends on two variables: whether the quality of SOPs generated by the Bubble Engine is stable enough, and whether the speed of SOP coverage can keep up with changes in user needs and general Agent capabilities.

But at least at the current stage, for individuals without a technical background and small and medium-sized enterprises, xBubble provides a different path: not learning the entire AI toolchain first and then trying to use AI, but directly encapsulating cutting-edge AI productivity into reusable workflows through task-level SOPs.

Users clarify their goals, and xBubble handles the underlying AI operations.

About DAPPOS

DAPPOS is an artificial intelligence company focused on low-threshold AI products, building easier-to-use AI workflows for ordinary and professional users. DAPPOS has completed over $20 million in financing, with investors including Polychain, Binance Labs, Sequoia China, IDG Capital, OKX Ventures, and other institutions.

About xBubble

xBubble is a low-prompt AI Agent product launched by DAPPOS, aimed at helping users complete tasks such as documents, PPTs, websites, images, videos, research, automation, and scheduled tasks with shorter requirement descriptions.

xBubble encapsulates cutting-edge AI productivity at a lower learning cost for ordinary users through task-level SOPs, allowing users to gain professional-level AI productivity without needing to learn the entire AI toolchain.