In recent months, "Vibe Coding" has become a viral buzzword. A wave of tools led by Cursor and Claude Code is pushing software development efficiency to new heights.
For developers familiar with engineering systems, this represents a leap in productivity. They can accomplish more in less time, even building complex systems through an approach resembling "conversation."
However, this efficiency revolution does not yet truly belong to the majority.
Even though AI can generate tens of thousands of lines of code, ordinary users remain blocked by cumbersome steps like IDE configuration, dependency management, and cloud deployment. Vibe Coding has accelerated coding speed by orders of magnitude but has barely lowered the barrier to turning code into usable software—it accelerates coding, not delivery.
Facing this disconnect, the industry's technical roadmap has diverged. One path continues to strengthen "making programmers code faster," while the other attempts to answer a more fundamental question: Can we skip the code entirely and deliver software directly?
The Ant Group's Lingguang App, fully upgraded on April 20, is a noteworthy sample of this latter direction. It attempts to reconstruct software production relations through "Wish Coding" (Intent Programming).
So-called Wish Coding essentially downgrades 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 state the desired function in natural language. The system then completes the entire chain from code generation to packaging and launch in the background, ultimately delivering a ready-to-use application entity.
This is worth serious discussion because it attempts to fill a long-missing link in AI programming: enabling ordinary people to complete the closed loop from idea to runnable application.
From Code Generation to Software Delivery: What Layer is Truly Missing?
Over the past two years, AI programming products have emerged in an endless stream. However, from a delivery perspective, they largely remain at a few levels:
- The first type delivers code snippets or project files, with Cursor being a typical example.
- The second type delivers editable, previewable project environments, represented by Bolt.new and Lovable.
- The third type is beginning to attempt providing integrated development, runtime, and deployment capabilities, such as Replit Agent.
These products are all valuable, but most still default to one assumption: the user is willing to enter the "development process," understand project structures, handle dependencies, debug errors, and decide how to publish.
For developers, this is not a problem; in fact, it is where the efficiency lies. But for ordinary users, any link in this chain can become a blocking point in actual use. They might use these tools to generate code, but they 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 get the result." These are two completely different design goals, corresponding to entirely different solution methods.
To this, Lingguang's answer is Zero DevOps. Processes like code compilation, environment packaging, and deployment are "nearly invisible" to the user. Users do not see any code; instead, they receive a final application that is ready to use immediately.
To achieve this end-to-end entity delivery, the system must solve the inherent ambiguity and divergence of natural language. User input is often imprecise, incomplete, or even self-contradictory. How to converge this into executable software? This leads to Lingguang's core underlying technical mechanism: the Structured Intent Representation Layer.
Content interpreted by Synthetic Intelligence; Image synthesized by AI
When a pure novice user inputs an instruction full of jumps or even logical loopholes, the large model's operation logic in the background is far more complex than simply spitting out code text.
Lingguang's agent acts as a system architect. It first parses natural language expressions into rigorous functional module trees and interaction flowcharts, defining underlying data dictionaries and coupling relationships between modules in a high-dimensional semantic space. Only after ensuring the logical loop is complete does the system perform dynamic code assembly based on this intermediate structure. This modular underlying architecture design ensures that the generated application has a sufficiently solid skeleton. It can withstand multiple subsequent modifications and refactoring based on natural language, effectively avoiding system crashes caused by disordered code piling.
A more meaningful breakthrough lies in the 打通 of the native runtime environment on the device side. Currently, many AI application generation platforms, limited by browser sandboxes, can only produce outputs capable of simple DOM (Document Object Model) manipulation and page rendering. Lingguang's "Flash Apps," however, sink directly into the mobile native container. With user authorization, they can access real-time LBS positioning, read gyroscope tilt and acceleration data, and even control the feedback frequency and intensity of vibration motors.
Field Test: How Far Can One Sentence Go?
We also conducted some field tests. For example, we asked Lingguang to design a "My Soul Animal" test similar to SBTI.
We required the system to construct 30 bizarre multiple-choice questions and, upon completion of the test, output results such as "Melancholy and Thoughtful Elephant" or "Joke-Loving Capybara." Additionally, it had to accurately render a hexagonal radar attribute chart containing six weird dimensions: intelligence, brain-hole power (creativity), drama precision, etc.
In less than two minutes, an independent mini-program application was built and launched directly within the chat window.
4x Speed Video
Although the system initially misunderstood our expected title "My Soul Animal" as "Soul Zoo," this minor flaw was instantly fixed with a simple supplementary instruction. From the smooth transition of the answer pages to the final rendering of the radar chart, the underlying interaction logic was quite clear and self-consistent.
Consumer-Grade Coding Agents: The Bet Isn't on Refinement
In the process of experiencing Lingguang, surprise and roughness arrived almost simultaneously.
For instance, in our tests, if a user asks Lingguang to build an AI visual recognition tool, it will likely only deliver a "simulator" with front-end UI interaction, without actually processing photographed or uploaded images. Furthermore, since natural language is full of ambiguity and divergence, when users input contradictory modification instructions in multi-turn conversations, Lingguang occasionally falls into logical confusion, leading to bugs. At the same time, the UI of the generated applications remains stiff, making it obvious at a glance that it was made by AI.
However, measuring Flash Apps by the standards of industrial-grade finished software, or benchmarking Lingguang against the AI programming tools pursued by professional developers for extreme efficiency, is itself a misplaced comparison.
As a consumer-grade Coding Agent aimed at the general public, Lingguang solves a completely different proposition: How to deliver a functional, closed-loop, runnable system to users with no technical background within a completely unstructured input space?
It must be known that ordinary users' input is often full of ambiguity and jumps, and the system must simultaneously play the roles of product manager, architect, designer, and programmer. In this high-dimensional semantic convergence process, priority is inevitably given to ensuring functional closure and immediate usability, thus necessitating compromises in visual design or certain deep logics.
This roughness is precisely the inevitable stage for software engineering moving from "elite manufacturing" to "mass expression."
This is highly similar to the evolution path of early internet products—the earliest web pages were rough and interactions were chaotic, but they first achieved "accessibility"; early mobile apps had unstable performance, but they率先 completed the paradigm shift to "always available." At every critical point of technology popularization, "usability" always takes precedence over "perfection."
For professional developers, a piece of flawless underlying algorithm code may be worth a fortune. But for 99% of ordinary people with no programming experience, a complete application that is merely passable but can be clicked and run immediately on a mobile phone releases far more productivity value than a perfect but fragmented code snippet displayed in a sandbox.
This is the underlying logic of the "Consumer-Grade Coding Agent." As long as the application it produces can run stably, is immediately usable, and can be continuously modified and iterated, it has crossed the critical threshold from AI-generated code to AI-delivered software.
The real bet of Consumer-Grade Coding Agents is not on how refined the applications they generate can be right now, but on whether they open up a new possibility: when the cost of trial and error approaches zero, ordinary people can also turn their intentions into reality-ready applications. Lingguang has preliminarily verified that the link from "intent to application" is feasible.
The Great Age of Creativity is Arriving...
This upgrade of Lingguang also simultaneously launched the "Lingguang Circle"—an AI application "Moments" introducing collaboration and distribution capabilities. Users can share the Flash Apps they create within it, or build upon others' works using natural language for relay modifications, 堪称 an open-source community of intent.
When Flash Apps begin to carry social attributes, circulating in the community and being relay-modified by others, we glimpse a new model of software self-evolution.
In traditional software engineering, application iteration relies heavily on the planning of development teams and long release cycles. But in the collaborative network built by Wish Coding, the form of software undergoes a qualitative change; it becomes more like plug-and-play digital content. Users can instantly create a tool to solve a specific, tiny pain point, use it and leave, and still leave it in the community, waiting for the next person with a similar need to continue the relay transformation 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 rapidly generated, used, modified, and redistributed. Software also begins to possess evolutionary characteristics similar to content platforms.
Of course, we must clearly see the boundaries. For professional engineers, the construction of complex systems remains irreplaceable. Complex systems, high-reliability applications, and critical infrastructure will still离不开 serious software engineering methods in the short term. Determinism, maintainability, testability, and compliance—these requirements will not become unimportant due to natural language generation; on the contrary, they will continue to be amplified in higher-value systems.
But for a broader population, the threshold for creating digital tools is dropping. Wish Coding may open up a completely new software production layer outside of professional development, one that did not exist before. Here, the standard for measuring creativity is shifting from "code implementation ability" to "intent expression ability."
In this sense, Wish Coding lets us see a possibility: when describing a requirement becomes harder than implementing it, the bottleneck of software engineering shifts from technical capability to intent expression capability. We may be standing at the early stage of this transition.
In today's era where code generation capabilities are accelerating towards democratization, Lingguang, at the cost of tolerating the roughness of early-stage products, has forged a path for C-end equity. For the vast majority of ordinary people who have never stepped into the world of code, this Great Age of Navigation for wild creativity has just begun.
© THE END
Please contact our official account for reprint authorization.
Submission or media inquiries: liyazhou@jiqizhixin.com