Wish-Based Programming: The Technical Evolution of Natural Language App Generation

    This article examines "wish-based programming"—the practice of describing a goal in natural language so an AI model can generate a runnable application—from an engineering perspective rather than treating it as magic. It traces the shift from code completion to full application generation, explains why these tools can suddenly feel more capable, and breaks down the core capabilities involved: requirement understanding, task planning, code generation, execution verification, automatic repair, and delivery explanation. It also provides a practical prompt structure for writing clear "wishes," a quality-assurance checklist covering correctness, maintainability, security, performance, compatibility, and observability, and a discussion of where the approach works well and where caution is needed. The conclusion proposes a four-point evaluation framework and outlines future directions toward more reliable delivery.

    Recently, “wish-based programming” has become a topic of interest in developer communities: users simply describe their needs in natural language, and an intelligent model can generate a runnable webpage, mini-game, 3D demo, or data-processing tool. On the surface, this looks like the magic of “generating an app with a single sentence.” But from an engineering perspective, it is actually the combined result of several capabilities: understanding requirements, generating code, executing and verifying, fixing errors, and explaining the delivery.

    To evaluate these capabilities, we cannot stop at the level of “can it generate something.” We should also focus on whether it can reliably produce value in real development workflows. In other words, the real question worth discussing is not “whether it is like magic,” but “which originally high-cost development steps does it make easier,” “which scenarios are best suited for it,” and “which steps still require human oversight.”

    1. From Code Completion to App Generation: How Development Is Changing

    Early intelligent coding tools mainly solved the problem of “writing code faster.” For example, completing functions based on context, suggesting variable names, and generating simple templates. The value at this stage was mainly reflected in micro-level coding efficiency, and developers still had to complete requirement breakdown, architecture design, and debugging themselves.

    Then conversational coding capabilities gradually improved. Developers could describe a function, a page module, or a piece of business logic in natural language, and the model would generate the corresponding code based on context. At this point, the tool’s role changed from a “completion engine” to a “coding assistant.”

    “Wish-based programming” pushes this further: users no longer just describe a function, but directly describe a complete goal, such as “make a playable web mini-game,” “generate a data display page,” or “build a simple form-processing tool.” The model has to handle a more complete task chain: understanding the goal, breaking down modules, generating code, providing run instructions, and even fixing issues when they fail.

    This means development is shifting from “writing code line by line” to “defining problems, verifying results, and managing the process.” The core skills of developers are changing too: prompt expression, requirement clarification, acceptance criteria design, code review, and system architecture judgment are becoming more important than simply memorizing syntax.

    2. Why It Suddenly Feels Stronger

    Many users feel that a certain version “suddenly got stronger.” This experience can come from multiple factors and cannot be simply attributed to a sudden leap in one capability.

    First, model capabilities keep iterating. Language understanding, logical reasoning, code generation, long-context processing, structured output, and other abilities can all be optimized in different versions.

    Second, the engineering pipeline becomes more complete. Even if the model itself changes little, improvements in context management, error feedback, execution environment, and result verification can significantly improve the “usability” that users perceive.

    Third, task distribution affects subjective judgment. If a user happens to try a task the model is good at—such as a clearly structured mini-game, a common page layout, or a standardized script—it is easy to get the impression that it “suddenly became usable.”

    Fourth, server-side policies and routing mechanisms may also affect the experience. Different requests may enter different configurations, and different time periods may hit different policies, causing the same question to produce different outputs.

    Therefore, judging whether a model or an intelligent coding service has truly improved cannot rely on a single experience. It requires a more systematic evaluation: a fixed task set, multiple rounds of verification, observing stability, recording failure types, and combining code review with run results. Version identifiers and fingerprint information can serve as auxiliary observation signals, but not as the sole conclusion.

    3. Breaking Down the Core Capabilities of Wish-Based Programming

    To turn a “wish” into a deliverable result, at least the following types of capabilities need to work together.

    1. Requirement Understanding

    User input is often very brief, such as “make a racing game,” “generate a data dashboard,” or “write a script that automatically organizes files.” The system needs to fill in implicit information: what the runtime platform is, who the user is, what the input and output are, whether state needs to be saved, whether errors need to be handled, and what the performance requirements are.

    Without clarification, the model can only guess based on common patterns. So the clearer the prompt, the more stable the generated result.

    2. Task Planning

    A complex application cannot be generated in one step. The model needs to break the requirement into page structure, interaction logic, data models, state management, styling, error handling, and other parts. Planning ability determines whether the generated code is maintainable.

    3. Code Generation

    Code generation is not just about “writing it out,” but also about reasonable structure, clear naming, consistent logic, and adequate consideration of edge cases. For multi-file projects, it also needs to maintain consistent interfaces between modules.

    4. Execution Verification

    Truly valuable generation is not just outputting text, but being able to verify whether the result runs. For example, checking syntax, viewing run logs, determining whether the page loads normally, and confirming whether key interactions work. Generation without verification easily stays at the “looks like it works” level.

    5. Automatic Repair

    When execution fails, the system needs to read the error information, locate the problem, and propose the minimal fix. For example, a missing numeric check, an unbound event, a style conflict, or a failed resource load. The stronger the repair ability, the closer it gets to a “usable prototype.”

    6. Explanation and Delivery

    The generated result ultimately has to be used by people. So it needs to explain how to run it, which environments it depends on, how to modify it, and how to deploy it. The quality of the delivery notes determines whether the application can be understood and used by non-developers.

    4. How to Write a Good “Wish”: Prompt Design Methods

    The effectiveness of wish-based programming largely depends on whether the requirement is expressed clearly. A practical prompt structure can include the goal, the user, input and output, a feature list, non-functional requirements, technical constraints, acceptance criteria, and failure handling.

    A sample template:

    1. Act as a senior full-stack engineer and complete the following task:
    2. 1. Goal:
    3. Build an interactive application that runs in a web browser.
    4. 2. Users:
    5. General users who do not need to install extra software.
    6. 3. Input:
    7. Users interact via natural language or buttons.
    8. 4. Output:
    9. The page gives real-time feedback on actions.
    10. 5. Feature list:
    11. - The page includes a title, an action area, and a result area
    12. - Supports start, pause, and reset
    13. - Supports score tracking or state saving
    14. - Shows a clear message on error
    15. 6. Non-functional requirements:
    16. - No login required on first load
    17. - Clean UI, responsive for desktop and mobile
    18. - Key logic can be split out for later extension
    19. 7. Technical constraints:
    20. - Does not depend on an external account system
    21. - Does not depend on uncontrollable third-party resources
    22. - Clear code structure with sufficient comments
    23. 8. Acceptance criteria:
    24. - Usable immediately upon opening
    25. - Core actions have clear feedback
    26. - Abnormal states do not crash the page
    27. 9. Deliverables:
    28. - Page code
    29. - Documentation
    30. - Run instructions

    If the task is more complex, you can also proceed step by step:

    Step 1: First have the model output clarifying questions about the requirements.
    Step 2: Then output the page structure and module breakdown.
    Step 3: Then generate the core logic.
    Step 4: Finally, perform run checks and fixes.

    This approach is more stable than asking to “directly generate a complete project” in one go, because it reduces ambiguity and makes each step verifiable.

    5. From Demo Prototype to Usable App: Quality Assurance Is Not Optional

    Wish-based programming most easily creates an illusion: that something which “looks like it runs” is truly usable. In fact, there is a clear gap between a prototype and a usable application.

    1. Functional Correctness

    You need to verify whether the core paths are complete. For example, whether buttons trigger, whether data is saved, whether invalid input is blocked, and whether state is lost after a refresh. It is recommended to build a minimal acceptance checklist rather than judge by feel.

    2. Code Maintainability

    If the generated code is just an unreadable blob of logic, the cost of later modifications will be high. You should pay attention to module division, naming conventions, comment completeness, and the separation of configuration files.

    3. Security

    Especially for applications that involve input, files, network requests, and user data, you must check input validation, access control, sensitive information storage, and other issues. Do not write keys, tokens, or internal addresses directly into front-end code.

    4. Performance

    You need to pay attention to loading speed, resource size, runtime smoothness, memory usage, and so on. For animation, rendering, and real-time computing applications, performance problems are often more easily overlooked than functional errors.

    5. Compatibility

    The same page may behave inconsistently across different screen sizes, browser environments, and input methods. Basic compatibility checks should be done before delivery.

    6. Observability

    Once an application goes live or enters long-term use, you need to know where errors occur and why. Common practices include logging, error monitoring, and alert configuration. In a cloud service environment, you can also combine object storage, log services, monitoring and alerting, container platforms, and other general capabilities to complete deployment, observability, and operations.

    6. Where Are the Boundaries of Wish-Based Programming

    These capabilities are not suitable for all scenarios. They have clear advantages and clear boundaries.

    Advantageous scenarios include:

    • Rapid prototyping: validating whether an idea is feasible.
    • Teaching demos: turning abstract concepts into interactive cases.
    • Small tool development: reducing repetitive coding time.
    • Internal system assistance: generating forms, pages, scripts, and other common modules.
    • Exploring non-standard tasks: allowing non-professional developers to participate in product building.

    But the following scenarios require caution:

    First, systems with many complex business rules. Such systems involve a lot of domain knowledge, approval workflows, and state transitions, which the model struggles to understand accurately in one pass.

    Second, high-security scenarios. Applications related to finance, healthcare, sensitive permissions, and private data must go through strict review and testing.

    Third, long-term evolving projects. If the code lacks architectural constraints, relying on continuous generation alone easily forms an unmaintainable pile.

    Fourth, experience-driven products. Interaction details, visual aesthetics, animation timing, and user psychological expectations still require professional judgment.

    Fifth, high-risk automation tasks. When actions such as deletion, release, permission changes, and financial operations are involved, there must be a clear confirmation mechanism and rollback plan.

    7. A More Reasonable Evaluation: Not Slogans, but the Closed Loop

    “Wish-based programming” should not be simply understood as “get a complete piece of software by entering one sentence.” A more reasonable understanding is: it lowers part of the barrier to building software, compresses part of the repetitive work, and shortens part of the prototype validation cycle.

    A truly mature evaluation should look at four metrics:

    1. Whether it can turn a natural language goal into an executable plan.
    2. Whether it can generate structurally complete, maintainable code.
    3. Whether it can find and fix problems through run feedback.
    4. Whether human review can become part of a secure closed loop.

    If it only satisfies “looks like it generated something,” but there is no running, no verification, no fixing, and no review, then it is just a demo, not engineering.

    8. Future Direction: From “Can Generate” to “Can Deliver”

    Next, the development focus of these capabilities will not just be “generating more convincingly,” but “delivering more reliably.” A few directions to observe:

    First, more refined context management. The larger the project, the more you need to maintain long-term consistency and avoid conflicts between earlier and later code.

    Second, more automatic execution verification. Generated results can run in a sandbox and self-check through logs, screenshots, interaction results, and other means.

    Third, more natural human-machine collaboration. Users can not only state requirements but also adjust direction at any time, replace modules, and adjust priorities.

    Fourth, a more complete quality system. Type checking, static analysis, test cases, performance evaluation, security scanning, and other steps will gradually become standard procedures.

    Fifth, clearer applicable boundaries. Which tasks are suitable for automatic generation and which must be led by humans will gradually form a more mature practical consensus.

    Overall, wish-based programming represents an inclusive trend: more and more people can participate in software building with natural language, and developers can shift their energy from repetitive work to problem definition, system design, and quality control. It will not eliminate engineering; rather, it will make the focus of engineering clearer. What really matters is not the slogan of “make it real with one click,” but whether a complete closed loop can be established—from requirement to delivery, from generation to verification, and from prototype to maintenance.