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 can 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 at the moment:

1. If they try to use it directly, they need to spend a lot of time learning and debugging. Different models have different capability boundaries, prompt writing styles vary, 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 conflict with the usage habits of many users. Many people prefer to write all their 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 getting close to the desired result.

2. If they hire someone to use it, it is usually hard to find the right person, there isn't a stable amount of work, and it incurs additional salary costs. Finding an employee who is proactive and can effectively use AI is actually not easy; most employees work passively for a paycheck, and communicating with them may not be as effective as using AI directly. The result may be that money is invested in 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 the underlying large models in AI? It seems difficult at the moment.

The existence of Skills itself proves that the direct output of large models often cannot meet specific needs and requires the improvement of effects through predefined Skills. Even if in the future AI becomes as smart as humans, this problem 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 a challenging task.

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

xBubble, launched by DAPPOS, aims precisely at this area. Its approach is not to require every user to become an AI expert or to learn Vibe Coding, but to implement the encapsulation of Vibe Coders through an SOP system, helping non-technical small and medium-sized enterprises or individuals use AI without needing to spend time learning and debugging or hiring 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, xBubble's product architecture 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, constructing solutions for specific tasks through AI coding agents, 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 solution from the SOP library to execute. If there is no suitable dedicated SOP, it can also 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 an entry point that is closer to "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. Actual output also depends on what model is used, what environment it runs in, whether necessary APIs are integrated, 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 choose models separately, configure APIs, 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 solve problems within a verified scope and are tested within that range. Therefore, when a task falls within the SOP description range, the effects are usually quite stable.

This is somewhat different from the logic of open-source Skills. Open-source Skills often pursue more stars and tend to be more general. While generality has its benefits, the downside is that many Skills are not adequately 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 is essentially the work of a Vibe Coder.

xBubble's SOP emphasizes the verified applicable range. It does not mean that an SOP can do everything, but rather that within the defined and tested range, it aims to produce stable results.

2. Simple and Easy to Use

SOPs take 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 called 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 usually 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 services of Bubble Engine (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 shifted 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. Open-source Skills are often too general and struggle to cover more customized needs like 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 that complexity, allowing them to self-generate dedicated SOPs through Bubble Engine.

At the same time, the applicable range of SOPs can be large or small. For example, in Work mode, if there is no dedicated SOP to 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 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, SOPs are trained using Bubble Engine, with the goal of replacing Vibe Coders and directly generating SOPs that meet user needs. Mechanically, SOPs can be viewed as a function that maps specific prompts to results. Therefore, the problem to be solved for performance tuning can be simplified to:

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 the output the user truly desires.

Training Cases

The training of SOPs revolves around cases.

Users can directly send some cases they believe meet the requirements, such as prompts referencing 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 can imitate.

If there are no relevant cases in the training task, 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 serve as 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 outcomes 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 Loop

Next, 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, while the training results may look good, the actual usage may have poor generalization ability.

After development is complete, the system will run tests using 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 indicated by the user in the training task. For example, checking if the format is correct, if the content is complete, and if it meets the explicit limitations set by the user.

2. Assessing whether the results are sufficiently similar to the cases. For example, checking the style, structure, content organization, and output form to see if they are close 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 was originally done manually by Vibe Coders: reviewing cases, writing plans, running results, identifying problems, modifying plans, and iterating repeatedly.

Scope Definition

Once the performance-tuned SOP is completed, it still needs to define its applicable scope before being integrated into the system.

This step is crucial. Because having more dedicated SOPs is not necessarily better, nor should any SOP be prioritized at all times. If an SOP is only effective for a very narrow task but is used to handle broader issues, it may be worse than a general SOP.

Bubble Engine will determine which tasks this 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 effectiveness 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 requiring third-party paid APIs or tasks that current large models 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 the underlying AI models continue to advance, 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 configured? How to run it? What if the results are unstable? Can it be reused next time? If open-source Skills don't work, how do I create a usable Skill?"

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

Of course, how far this system can ultimately go still depends on two variables: one is whether the quality of SOPs generated by Bubble Engine is stable enough, and the other is 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 to 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 more user-friendly 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 others.

About xBubble

xBubble is a low-prompt AI Agent product launched by DAPPOS, designed to help 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 for ordinary users at a lower learning cost through task-level SOPs, allowing users to achieve professional-level AI productivity without needing to learn the entire AI toolchain.