Can Chinese LLMs Regain Their Glory: From Scale to Engineering Capability

    This article explores the true value of Chinese Large Language Models (LLMs) in enterprise engineering. Beyond benchmark scores and parameter sizes, real-world projects require models to understand implicit intents, maintain complex constraints, and identify risks. We analyze the differences between small and large parameter models, use a concurrency control case study to illustrate design comprehension, and propose a tiered strategy for enterprises to integrate LLMs into their development workflows effectively.

    Before discussing whether Chinese Large Language Models (LLMs) can “regain their glory,” a premise must be clarified: a model’s value is not solely reflected in Q&A scores, code completion speed, or single-turn dialogue performance. For general users, a model that quickly generates code or explains a concept is already helpful. However, for government, public sector, and large enterprise projects, the model’s responsibilities extend far beyond “writing code.”

    These projects typically must satisfy multiple constraints, including data security, deployment environments, permission isolation, audit trails, architectural standards, compatibility, maintainability, and internal organizational workflows. Often, developers do not need a tool that mechanically executes instructions; they need a collaborative partner that understands the context, identifies implicit goals, and proactively detects risks when constraints are incomplete. This is where the experience gap between different scale models becomes significantly amplified.

    1. Evaluating Model Capability Beyond Leaderboard Scores

    Public evaluations usually break down models into dimensions like mathematics, knowledge, reasoning, coding, and reading comprehension, calculating scores through standardized questions. While suitable for horizontal reference, this approach struggles to fully reflect the user experience in real-world projects.

    Enterprise development requirements are rarely isolated questions with clear boundaries; they are sets of interrelated constraints. For example:

    • Business objects have master-slave relationships;
    • Certain operations must be idempotent;
    • Data changes require audit logs;
    • Deletion operations are restricted by permissions and states;
    • Concurrency scenarios must avoid dirty writes, duplicate submissions, or data loss;
    • Code must adhere to the existing project’s layered architecture;
    • Even if a more “elegant” solution exists, it might be rejected due to team standards, migration costs, or maintenance habits.

    It is difficult to express all these details in a brief prompt. Developers typically describe the business background first, then supplement it with existing code, database structures, exception scenarios, and team conventions. The model’s task is not just to generate syntactically correct code, but to infer from the context: what is the core objective, what is the implementation method, and what constitutes an inviolable project contract.

    Therefore, a model’s practical value should be evaluated across at least four dimensions:

    1. Explicit Instruction Execution: Can it complete tasks as required?
    2. Implicit Intent Comprehension: Can it understand the business goals behind the requirements?
    3. Constraint Maintenance: Can it avoid arbitrarily altering the design under complex conditions?
    4. Risk Identification: Can it proactively point out issues like concurrency, security, and data consistency?

    A high score in individual tests does not guarantee the same performance across all real-world engineering scenarios.

    2. Small Models for Execution, Large Models for Collaboration

    Small parameter models do not mean “poor capability.” In tasks with clear boundaries, explicit goals, and standardized inputs, small models often offer advantages like fast response times, low deployment costs, and minimal resource consumption. For example, the following tasks are well-suited for lightweight models:

    • Generating CRUD code based on explicit fields;
    • Batch supplementing simple data structures;
    • Generating API documentation in a fixed format;
    • Converting one syntax to another;
    • Writing uniformly formatted test cases;
    • Categorizing logs, configurations, and simple errors;
    • Executing repetitive tasks in an already finalized plan.

    The common characteristic of these tasks is that the mapping between input and output is stable, ambiguity in requirements is low, and the developer has already completed the main design work.

    The problem is that real projects often exist in a phase where “requirements have been proposed, but the design is not yet fully expanded.” At this point, a developer might only say: “Add exclusive control to data and archive operations to prevent concurrent deletion issues.” This sentence seems to contain the goal on the surface, but still lacks many key details:

    • What exactly is the lock target: the data record, the archive directory, or a specific file?
    • How is the lock lifecycle managed?
    • Do delete, update, and archive operations share the same lock?
    • Is the lock released if the operation fails?
    • How is lock timeout handled?
    • When multiple users operate on the same data simultaneously, who has priority?
    • Do background tasks and foreground operations use the same concurrency control rules?

    If the model only executes literally, it might choose a locking target that looks reasonable locally. For instance, since archives depend on a data entity, the model might lock the archive directory. Such an implementation might not be entirely wrong and might even pass existing tests, but it could deviate from the system’s true design intent.

    In more complex model collaboration, the model has the opportunity to reason further based on context: archives are subordinate entities of data, and deleting data affects all archives; therefore, the core object for concurrency control should be the business entity corresponding to the data primary key. This unifies the boundaries for data updates, archive operations, and deletions, reduces the complexity caused by scattered locking rules, and makes it easier to prevent data from being deleted by other users during background tasks.

    This shows that the advantage of large parameter models is not necessarily “generating more code,” but a higher likelihood of understanding the overall structure of the task and identifying the truly important constraints within incomplete expressions.

    3. A Concurrency Control Case Study: Running Code Does Not Mean Correct Design

    Take a data and archive management system as an example. Suppose a business data entity has multiple archive files attached to it. The system allows users to edit data, upload archives, and delete archives, while background tasks might perform archiving, cleanup, or synchronization.

    A common but easily scattered design is:

    1. Edit Data: Lock data record
    2. Upload Archive: Lock archive directory
    3. Delete Archive: Lock specific file
    4. Background Cleanup: Select lock object based on task type

    This scheme seems detailed but can actually cause multiple issues:

    1. Inconsistent Lock Granularity
      Different operations use different lock objects that are unaware of each other, potentially resulting in data being deleted while archives are still being modified.
    2. Fragmented Business Boundaries
      Archive operations and data operations belong to different locking systems, requiring developers to maintain additional complex state synchronization logic.
    3. Complex Exception Handling
      An operation might modify data first, then modify archives. If the two phases use different locks, a failure in either phase could leave an intermediate state.
    4. Insufficient Concurrency Test Coverage
      Unit tests might verify that data updates and archive uploads succeed individually, but may not cover the race condition where “data deletion and archive upload happen simultaneously.”

    A more unified design is to use the data primary key as the root object for business concurrency control. Any critical operation affecting the data entity and its attached archives establishes exclusive control around this primary key.

    The logical flow is as follows:

    1. Start Transaction
    2. Acquire exclusive control corresponding to the data primary key
    3. Validate data status and operator permissions
    4. Execute data or archive related operations
    5. Write audit records
    6. Commit Transaction and release control

    While this design is not absolutely correct in every system, it embodies an important principle: the object of concurrency control should be determined primarily around the business consistency boundary, rather than simply divided by database tables, folders, or page functions.

    If a model only sees the local task of “archive upload,” it might choose a lock at the archive level. If the model understands the subordinate relationship between data and archives, it is more likely to propose a unified business-entity-level control scheme.

    Of course, the final design still needs to be confirmed by developers considering database transaction mechanisms, distributed deployment, lock service reliability, and performance requirements. Models can help identify issues, but cannot replace architectural decisions and production verification.

    4. “Wishful Programming” Does Not Contradict Formal Engineering

    In recent years, many developers have adopted a more natural workflow: describing the goal in natural language first, letting the model generate the plan and code itself. This approach can be called “wishful programming,” and its core value is lowering the barrier to expression, freeing developers from writing every implementation detail into a strict template initially.

    However, “letting the model do it” does not mean “the project does not need rules.”

    In prototype development, personal tools, and proof-of-concept projects, the model can have significant freedom. As long as the functionality works and the code structure is not overly complex, the phased goal is met.

    In formal projects, the model must adhere to numerous existing contracts, such as:

    • Must use the existing layered architecture;
    • Must not change the input/output of public interfaces;
    • Must not introduce unapproved dependencies;
    • Must retain original exception codes;
    • All write operations must enter the audit chain;
    • Must not compromise readability for local performance gains;
    • Must be compatible with existing data and historical callers;
    • The design plan must facilitate future maintenance and handover.

    Sometimes, a model can propose a theoretically more advanced solution, but the project still cannot adopt it. Reasons might include high migration costs, team unfamiliarity, lack of operational support, or review standards that emphasize consistency and maintainability.

    Therefore, an excellent model does not just “propose a better solution”; it should understand when to insist on improvements and when to respect existing constraints. The optimal solution in engineering practice is often not the one with the highest local performance, but the one that balances correctness, readability, stability, cost, and organizational collaboration.

    5. Evaluating Comprehension Through Complex Reviews and Technical Arguments

    A model’s comprehension ability is reflected not only in writing code but also in analyzing opinions, reviewing plans, and summarizing disputes.

    Faced with a technical review, a weaker model might exhibit several typical behaviors:

    • Only restating the original text without extracting the central argument;
    • Treating all opinions equally, leaning towards simple compromise;
    • Ignoring context, interpreting local statements as absolute conclusions;
    • Only discussing surface phenomena without explaining underlying mechanisms;
    • “Muddying the waters” when seeing disputes, without judging whether the arguments hold.

    A more mature analysis should answer the following questions in turn:

    1. What is the core conclusion this text is truly trying to express?
    2. What premises is the conclusion based on?
    3. Which parts are facts, and which are empirical judgments?
    4. In which scenarios does the opinion hold, and in which will it fail?
    5. Are there counterexamples?
    6. If the opinion holds, what are the technical reasons?
    7. What impact does it have on real-world project decisions?

    Take “small models are for execution, large models are for understanding complex goals” as an example. This is not a simple judgment of superiority, but a question of matching task types with model capabilities. Small models may be more economical and efficient for explicit tasks, while large models are better suited for high-ambiguity, high-constraint, and cross-module collaboration tasks. The two do not replace each other; rather, they can form a tiered collaboration system.

    6. Establishing a Reasonable Model Usage Strategy in Enterprises

    Enterprises should not simplify model selection to “bigger parameters are better,” nor should they make decisions based solely on a single test result. A more reasonable approach is to establish task grading and risk grading mechanisms.

    6.1 Division of Labor Based on Task Complexity

    Tasks can be divided into three categories:

    Category 1: Execution tasks with clear rules.
    For example, format conversion, code completion, document organization, and simple test generation. These tasks prioritize response speed, deployment cost, and stability.

    Category 2: Development tasks requiring context understanding.
    For example, module refactoring, interface design, exception handling, and database transaction orchestration. These tasks require stronger context association capabilities, should use models with better comprehension, and must be paired with human review.

    Category 3: High-risk decision tasks.
    For example, permission systems, data deletion, core transactions, privacy processing, and security policy design. Models can only serve as auxiliary analysis tools here and must undergo architectural review, test verification, and deployment approval.

    6.2 Setting Human Review Based on Risk Level

    For general code, sampling review can be adopted; for code involving data consistency, permissions, and deletion operations, mandatory human review should be enforced. Review focuses include:

    • Whether the original business semantics were altered;
    • Whether exception branches were omitted;
    • Whether concurrency races exist;
    • Whether repeated execution is possible;
    • Whether unreleased resources are left behind;
    • Whether security checks are placed incorrectly;
    • Whether existing compatibility was broken.

    6.3 Let the Model Explain First, Then Generate Code

    In complex tasks, do not immediately ask the model to output the complete implementation. You can first require it to complete the following:

    1. Please explain first:
    2. 1. The business goal you understand;
    3. 2. Key business entities and their relationships;
    4. 3. Potential concurrency and exception scenarios;
    5. 4. The design boundaries you plan to adopt;
    6. 5. Missing requirement information;
    7. 6. The potential costs of the plan.
    8. Generate code after confirming the design.

    This process forces the model to explicitly express its reasoning, making it easier for developers to correct misunderstandings promptly, preventing wrong plans from being expanded into massive amounts of code.

    7. Evaluating Chinese LLMs Through Real-World Productivity

    Whether Chinese LLMs can regain their glory depends not on whether they can top a specific leaderboard, but on whether they can consistently solve real user problems.

    For enterprises, the metrics truly worth paying attention to include:

    • Suitability for localized or compliant deployment;
    • Ability to understand long-term project context;
    • Stability in adhering to team standards;
    • Ability to reduce rework and communication costs;
    • Ability to proactively expose risks in complex scenarios;
    • Ease of integration into existing R&D workflows;
    • Ability to pass testing, auditing, and permission management;
    • Whether the overall usage cost is acceptable.

    If a model only works correctly when instructions are extremely precise, it is more of a high-efficiency executor. A model that can understand goals, identify ambiguities, explain solutions, and respect engineering constraints is closer to a true development collaborator.

    Therefore, future competition will not just be about parameter scale or single-turn Q&A quality, but a comprehensive competition of model capability, toolchains, data governance, deployment compliance, evaluation systems, and R&D workflows. To truly win over developers and enterprise users, Chinese LLMs must evolve from “generating content” to “understanding systems, adhering to contracts, and taking on collaborative responsibilities.”

    This is perhaps the core standard for evaluating whether a large model has long-term value.