Can Large Domestic LLMs Revive Intelligent Coding in China?

    Large domestic Chinese LLMs have improved rapidly in code generation, requirements analysis, and intelligent programming, but benchmark scores and single-answer quality do not fully reflect long-term engineering value. This article examines why intelligent coding requires intent understanding, implicit-constraint reasoning, engineering-contract compliance, and controlled execution; compares how small and large models fit different tasks; uses a locking-granularity example to show why runnable code may still violate system design; and offers practical guidance for model selection, workflow design, and maturity evaluation.

    In recent years, domestic Chinese LLMs have continued to improve in code generation, requirements analysis, and intelligent programming. Many developers find in practice that benchmark results, single-response quality, and long-term project experience do not always align. Some models respond quickly and act directly on simple tasks, making them suitable for batch code changes. Others are better at understanding vague goals, identifying implicit constraints, and completing complex work along the developer’s intended design path.

    Evaluating a large-parameter domestic model therefore requires more than checking whether it can “write the code.” It also requires checking whether the model truly understands why the project is designed the way it is, which parts cannot be changed casually, and whether it can proactively surface key risks when requirements are incomplete. “Reviving the glory” is not fundamentally about a one-time jump in benchmark ranking. It is about whether domestic models can form stable, controllable, and sustainable productivity in real engineering environments.

    1. The Core of Intelligent Coding Is Not Just Code Generation

    Traditional code generation can often be described as a relatively clear input-output problem: the developer provides a function requirement, data structures, and constraints, and the model generates the corresponding implementation. Such tasks suit smaller models with faster response times.

    Formal enterprise projects, however, rarely contain only a single function. A complete requirement usually includes several dimensions at once:

    • business goals and usage boundaries;
    • data structures in the existing system;
    • legacy code and compatibility requirements;
    • permission, transaction, concurrency, and audit rules;
    • performance targets and exception-handling approaches;
    • code style agreed upon by the team;
    • interfaces or existing behavior that cannot be modified.

    Some of this information is explicitly written in the prompt. Some is hidden in context, code structure, and business common sense. What the model really needs to do is not simply convert natural language into code, but infer from multiple sources of information what problem the developer is actually trying to solve.

    This is also why large-parameter models often deliver a better experience. They usually have stronger context-integration capabilities and can combine requirement descriptions, prior conversations, code relationships, and constraints instead of giving a local answer only to the last sentence.

    2. Small Models Are Good at Execution; Large Models Are Better at Understanding

    Small-parameter models are not without value. On the contrary, they often offer advantages in speed, cost, and execution stability for tasks such as format conversion, batch refactoring, simple interface completion, test-case generation, and comment cleanup.

    For example, the following tasks usually do not require strong intent-reasoning ability:

    1. Convert a set of fields into a specified data structure.
    2. Add basic unit tests for existing functions.
    3. Generate data-validation code according to explicit rules.
    4. Batch-standardize variable naming and comment formats.
    5. Generate interface documentation from a fixed template.

    These tasks share common characteristics: clear goals, well-defined boundaries, and errors that are easy to detect. As long as the prompt is complete enough, a small-parameter model can also deliver acceptable results.

    The problem is that requirements in real projects are often incomplete. A developer may only say, “Add exclusive control to this data,” without further specifying whether the controlled object is the master data, an attachment record, a file directory, or some intermediate state. A small model may choose an implementation that sounds semantically reasonable and passes tests, but it may not match the design goal of the entire system.

    The advantage of large-parameter models lies in judging implicit intent. They may further ask:

    • Which object is the core of the business operation?
    • Should the control granularity cover a complete data record or only attached resources?
    • Are there race conditions among deletion, update, and archiving?
    • At which transaction stage should the lock lifecycle end?
    • Could the current approach cause background jobs and user operations to overwrite each other?

    These questions may not appear directly in the requirement text, but they determine whether the solution is truly reliable.

    3. A Typical Case: Locking the Wrong Object Can Still Pass Tests

    Suppose a system contains a piece of business data associated with multiple archive files. The archives depend on the business data. Users can edit, delete, or archive the business data, and they can also adjust related archives independently.

    To avoid data inconsistency caused by concurrent operations, the system needs exclusive control. If the requirement only says “lock during archive operations,” a model may lock by archive directory identifier. This implementation is not completely wrong, because it can indeed prevent multiple requests from modifying the same archive directory at the same time, and some tests may pass.

    From the overall design perspective, however, the object that truly needs protection may be the business data itself. Reasons include:

    • the lifecycle of archives depends on the business data;
    • deleting business data requires handling archives at the same time;
    • a background job may be processing business data while a foreground user is modifying archives;
    • locking only the archive directory cannot prevent another request from deleting the master data;
    • when multiple archives exist, locking each one individually increases code complexity;
    • using master data as the lock granularity makes it easier to unify transaction boundaries and exception handling.

    A more reasonable design may therefore be to establish exclusive control around the primary key of the business data and then handle archive changes within the same transaction. The key point here is not a specific line of code, but whether the model can understand the dependency relationships between data entities and choose the correct concurrency-control object according to system design.

    This shows that code “running” and a solution “matching the design” are two different things. The former can be verified through local tests; the latter requires the model to understand business semantics, data relationships, and engineering constraints.

    4. Wish-Driven Programming and Formal Engineering Are Not Mutually Exclusive

    Many developers want to describe goals directly in natural language and let the model complete the solution design on its own. This approach can be called “wish-driven programming”: the developer describes the desired result, and the model breaks down tasks, generates code, and keeps revising.

    This approach is well suited to rapid idea validation, prototyping, and personal projects. In enterprise engineering, however, the model must also comply with many contracts. For example:

    • it must not change the response structure of existing interfaces;
    • it must not replace the database access method without authorization;
    • it must not introduce unapproved dependencies;
    • it must not bypass permission checks;
    • it must not write sensitive information into logs;
    • it must not sacrifice transaction consistency for performance;
    • it must not modify established error codes or exception-handling approaches.

    Sometimes a model can propose a theoretically better implementation, but the project still cannot adopt it. The reason may be that the team values readability, maintenance cost, release risk, or compatibility with existing systems more highly. Formal projects pursue not local optimization, but overall balance under constraints.

    An excellent model therefore must not only know how to “do things,” but also know which things must not be done. It should not only provide a result, but also explain why it chose that result and which existing behaviors it may affect.

    5. Why the Advantage of Large Models Often Shows Up as Fewer Retries

    Model pricing and quotas matter, but comparing only the cost of a single call is not enough. For complex tasks, it is more important to focus on the total cost required to complete the task.

    Total cost usually includes:

    • the cost of calls that generate code;
    • the time developers spend reading and modifying code;
    • the time spent re-describing requirements;
    • the time spent fixing hidden defects;
    • the cost of troubleshooting after test failures;
    • the risk cost of handling exceptions after release.

    A model that is cheap and fast to respond may not ultimately cost less if developers must repeatedly add context and correct its direction. Conversely, a large-parameter model may cost more per call, but if it understands goals more accurately and reduces rework, overall efficiency may be better.

    A simple formula can help:

    Total cost = model call cost + human review cost + rework cost + risk cost

    In complex projects, human review and rework costs are often far higher than the cost of a single model call. The value of large-parameter models lies precisely in reducing the latter three cost items through better intent recognition and solution completeness.

    6. Where Domestic Models Truly Need to Break Through

    If domestic Chinese LLMs want to build long-term competitiveness in intelligent programming, they need to continue improving in at least the following areas.

    1. Improve focus recognition in long contexts

    Context length does not equal context understanding. Models need to identify truly important information from large amounts of code, documentation, and historical conversations, and distinguish hard constraints, suggested requirements, and irrelevant background.

    2. Strengthen implicit-requirement reasoning

    Models should not wait only for developers to write every condition clearly. They should also proactively identify possible omissions related to concurrency, permissions, transactions, and data consistency, and ask valuable clarifying questions when uncertain.

    3. Improve sustained execution on complex tasks

    A large task usually goes through multiple stages: analysis, decomposition, modification, testing, and review. Models need to keep decisions consistent across stages and avoid silently breaking constraints established earlier during later modifications.

    4. Better adhere to engineering contracts

    Enterprise projects value stability, auditability, and maintainability. Models should strictly follow existing interfaces, directory structures, coding standards, dependency limits, and security requirements, rather than redesigning a seemingly more elegant solution every time.

    5. Strengthen result explanations and risk warnings

    When outputting code, models should ideally also explain key design choices, potential risks, uncovered boundary conditions, and recommended additional tests. This allows developers to review more efficiently instead of passively reading large amounts of code.

    7. How Developers Should Select and Combine Models

    In practice, not every task needs to be assigned to the same type of model. A more reasonable approach is to layer tasks according to their characteristics.

    For clear, repetitive, low-risk tasks, developers can choose faster and lower-cost models, such as format conversion, simple completion, and batch modification.

    For the following tasks, models with stronger understanding capabilities should be preferred:

    • requirement boundaries are incomplete;
    • multiple modules need to collaborate;
    • concurrency, transactions, and permissions are involved;
    • compatibility with legacy systems is required;
    • trade-offs among multiple solutions are needed;
    • code changes may affect core business operations;
    • true points need to be extracted from comments or documentation.

    At the same time, models cannot replace engineering verification. A recommended workflow is:

    1. Have the model summarize requirements and constraints.
    2. Have the model list uncertainties and potential risks.
    3. Generate a design proposal before generating code directly.
    4. Manually confirm key decisions.
    5. Modify code in stages.
    6. Automatically run tests, static checks, and security scans.
    7. Finally, have the model review the impact of the changes.

    This workflow is more robust than “generate all code in one sentence” and is better suited to enterprise environments.

    8. How to Judge Whether a Model Is Truly Mature

    When evaluating a model, several types of tests close to real work can be designed, rather than relying only on simple Q&A.

    The first is an ambiguous-requirement test. Give only the business goal and observe whether the model proactively clarifies key conditions.

    The second is an implicit-constraint test. Add interfaces that cannot be modified, performance requirements, or permission rules into the context, and check whether the model can consistently comply with them.

    The third is a conflicting-requirement test. Deliberately set two seemingly reasonable but mutually conflicting goals and observe whether the model can point out the contradiction instead of forcing an answer.

    The fourth is a long-running-task test. Ask the model to complete analysis, coding, testing, and fixing in sequence, and observe whether it forgets earlier decisions.

    The fifth is a code-review test. Provide code that “runs but is not well designed” and check whether the model can identify deeper problems rather than only pointing out formatting errors.

    From these dimensions, whether domestic models are competitive depends not only on parameter scale, but on whether scale can be translated into more accurate understanding, more stable execution, and lower engineering risk.

    Conclusion

    Whether domestic Chinese LLMs can revive intelligent coding ultimately depends on whether they can grow from “code generators” into “engineering collaborators.”

    Small-parameter models remain irreplaceable for execution-oriented tasks, while large-parameter models are better suited to complex goals, vague requirements, and multiple constraints. The two are not simply substitutes; they can form a division of labor: high-understanding models handle analysis, design, and review, while high-efficiency models handle batch execution and rapid iteration.

    A truly mature intelligent programming system does not blindly pursue larger parameters or higher benchmark scores. It lets models understand system goals, respect engineering contracts, proactively expose risks, and continuously deliver reliable results within a verifiable process. As long as domestic models can improve steadily on these real-world problems, they have an opportunity to build long-term advantages through compliance, cost, scenario fit, and engineering understanding.