From Vibe Coding to Wish Coding: AI Programming Reaches a Turning Point

In recent months, Vibe Coding has become a trending term. Tools like Cursor and Claude Code are pushing software development efficiency to new heights.

Developers familiar with engineering systems are experiencing a leap in productivity. They can accomplish more work in less time, even building complex systems in a near-conversational manner.

However, this efficiency revolution has not yet truly reached the majority. Even though AI can generate thousands of lines of code, ordinary users remain hindered by tedious steps such as IDE configuration, dependency management, and cloud deployment. Vibe Coding has accelerated coding speed significantly but has not lowered the barrier to turning code into usable software—it has sped up coding, not delivery.

Faced with this gap, the industry’s technical routes have diverged. One path continues to enhance “faster coding for programmers,” while another seeks to answer a more fundamental question: Can we skip coding and deliver software directly?

The newly upgraded Ant Lingguang App, launched on April 20, is a noteworthy example of the latter direction, attempting to reconstruct software production relationships through Wish Coding.

What is Wish Coding?

Wish Coding essentially shifts the starting point of software generation from “writing logic” to “describing intent.” In Lingguang’s architecture, traditional development environments, compilers, and deployment processes are hidden. Users do not need to think about implementation paths; they simply express desired functionalities in natural language, and the system will complete the entire process from code generation to packaging and deployment in the background, ultimately delivering a ready-to-use application.

This approach is worth serious discussion as it attempts to fill a long-missing link in AI programming: enabling ordinary people to complete the loop from idea to runnable application.

From Code Generation to Software Delivery

What layer is truly missing?

In the past two years, numerous AI programming products have emerged, but from a delivery perspective, they largely remain at several levels:

• The first type delivers code snippets or project files, typical examples being Cursor;
• The second type provides editable, previewable project environments, represented by Bolt.new and Lovable;
• The third type begins to offer integrated development, running, and deployment capabilities, such as Replit Agent.

These products are valuable, but they mostly assume one thing: users are willing to engage in the “development process,” understand project structures, handle dependencies, debug errors, and decide how to publish.

For developers, this is not an issue; it is even where efficiency lies. However, for ordinary users, any step in this chain can become a blocking point in practical use. They may be able to generate code using these tools but may not be able to actually run or use the application.

In other words, the former needs “faster development,” while the latter needs “no development, just results.” These are two entirely different design goals, corresponding to completely different problem-solving methods.

In response, Lingguang offers Zero DevOps. Code compilation, environment packaging, and deployment processes are nearly invisible to users. Users do not see any code; instead, they receive an immediately usable final application.

To achieve this end-to-end entity delivery, the system must address the inherent ambiguity and divergence of natural language. What users say is often imprecise, incomplete, or even contradictory. How can executable software be distilled from this? This leads to Lingguang’s core technological mechanism: structured intent representation layer.

When a complete novice inputs a statement full of leaps or even logical flaws, the logic behind the large model’s operation is far more complex than simply outputting code text.

Lingguang’s intelligent agent acts as a system architect. It first parses the natural language expression into a rigorous functional module tree and interaction flowchart, defining the underlying data dictionary and coupling relationships between modules in a high-dimensional semantic space. Only after ensuring the logical loop is complete does the system dynamically assemble code based on this intermediate structure. This modular underlying architecture design ensures that the generated application has a sufficiently robust skeleton, capable of withstanding subsequent modifications and reconstructions based on natural language, effectively avoiding system crashes caused by disordered code piling.

Meaningful Breakthroughs

Breaking Down Native Runtime Environments

Currently, many AI application generation platforms are limited by browser sandboxes, where generated products can only perform simple DOM (Document Object Model) operations and page rendering. Lingguang’s flash applications, however, directly sink into the native containers of mobile devices, allowing real-time LBS positioning, reading tilt and acceleration data from the gyroscope, and even controlling the feedback frequency and strength of vibration motors, all with user authorization.

Real-World Testing

How Far Can a Single Sentence Go?

We conducted some real-world tests, for example, asking Lingguang to design a “My Soul Animal” test similar to SBTI.

We requested the system to construct 30 bizarre multiple-choice questions and output results like “a melancholic elephant” or “a joke-loving capybara” after the test, while also accurately rendering a hexagonal radar attribute chart containing six quirky dimensions such as intelligence, creativity, and drama.

In less than two minutes, an independent small program application was built and launched directly in the dialogue box.

Although the system initially misunderstood our expected title “My Soul Animal” as “Soul Animal Park,” this minor flaw could be instantly fixed with a simple follow-up instruction. From the smooth transition to the question page to the final rendering of the radar chart, the underlying interaction logic was quite clear and coherent.

Consumer-Level Coding Agent

Not Betting on Refinement

During the experience with Lingguang, surprise and roughness hit simultaneously.

For instance, in our testing, if users ask Lingguang to build an AI visual recognition tool, it is likely to deliver only a front-end UI interaction “simulator” without truly processing captured or uploaded images. Additionally, due to the inherent ambiguity and divergence of natural language, when users input contradictory modification instructions in multi-turn dialogues, Lingguang occasionally falls into logical confusion, leading to bugs. Moreover, the generated application’s UI remains somewhat stiff, clearly indicating it was created by AI.

However, measuring flash applications against industrial-grade finished software standards, or comparing Lingguang with AI programming tools that pursue extreme efficiency in the hands of professional developers, is itself a misaligned comparison.

Lingguang, as a consumer-level Coding Agent aimed at the public, addresses a completely different proposition: how to deliver a functional closed-loop runnable system for users with no technical background in a completely unstructured input space?

Ordinary users’ inputs are often filled with ambiguity and leaps, and the system must simultaneously play the roles of product manager, architect, designer, and programmer. In this high-dimensional semantic convergence process, it will prioritize ensuring functional closure and immediate usability, thus inevitably making compromises in visual design or certain deeper logic.

This roughness is precisely the necessary stage for software engineering to transition from “elite manufacturing” to “mass expression.”

This evolution path is highly similar to the early evolution of internet products—initially, web pages were rough and interactions chaotic, but they first achieved “accessibility”; early mobile applications had unstable performance but completed the paradigm shift of “immediate usability.” At every critical point of technological popularization, “usability” always takes precedence over “perfection.”

For professional developers, a flawless underlying algorithm code may be worth a fortune. For 99% of ordinary people with no programming experience, a complete application that can be clicked and run on their phones, even if it is only at a passing level, releases far more productive value than showcasing perfect but incomplete code snippets in a sandbox.

This is the underlying logic of the “consumer-level Coding Agent.” As long as the applications it produces can run stably, be immediately usable, and can be continuously modified and iterated, it has crossed the critical threshold from AI-generated code to AI-delivered software.

The true bet of the consumer-level Coding Agent lies not in how refined the applications it can generate are at present, but in whether it opens up a new possibility: when the cost of trial and error approaches zero, ordinary people can also turn their intentions into usable applications. Lingguang has preliminarily validated that the link from intent to application is feasible.

The Age of Creative Exploration is Coming…

Lingguang’s upgrade also synchronously launched “Lingguang Circle”—an AI application social network that introduces collaboration and distribution capabilities. Users can share their created flash applications and modify others’ works using natural language, essentially creating an open-source community of intent.

As flash applications begin to carry social attributes, circulating in the community and being modified by others, we glimpse a new model of software self-evolution.

In traditional software engineering, application iteration heavily relies on the planning of development teams and lengthy release cycles. However, in the collaborative network built by Wish Coding, the form of software undergoes a qualitative change, resembling a plug-and-play digital content. Users can instantly create a tool to solve a specific minor pain point, use it, and leave it in the community for the next person with similar needs to continue modifying using natural language.

In such an ecosystem, the boundaries between software production and consumption begin to blur. Users are both consumers and creators; applications can be quickly generated, used, modified, and redistributed. Software begins to exhibit evolutionary characteristics similar to content platforms.

Of course, we must be clear about the existing boundaries. For professional engineers, constructing complex systems remains irreplaceable. Complex systems, high-reliability applications, and critical infrastructure still rely on serious software engineering methods in the short term. Requirements for determinism, maintainability, testability, and compliance will not become unimportant due to natural language generation; rather, they will continue to be amplified in higher-value systems.

However, for a broader audience, the barriers to creating digital tools are lowering. Wish Coding may open up an entirely new layer of software production that previously did not exist beyond professional development. Here, the standard for measuring creativity is shifting from “code implementation ability” to “intent expression ability.”

In this sense, Wish Coding shows us a possibility: when describing a requirement becomes more challenging than implementing it, the bottleneck of software engineering shifts from technical capability to intent expression ability. We may be standing at the early stage of this transition.

As code generation capabilities accelerate towards democratization, Lingguang has paved a path for C-end equality at the cost of tolerating early product roughness. For the vast majority of ordinary people who have never ventured into the world of code, this era of wild creativity is just beginning.