Can Large Chinese LLMs Revive Intelligent Programming?
The discussion about whether large Chinese LLMs can regain competitiveness should move beyond benchmark scores. This article examines model evaluation, intent-driven programming, the division of labor between small and large models, total cost of ownership, compliance and controllability, and a layered workflow in which strong models plan and lightweight models execute. It concludes that the real breakthrough lies in understanding projects, constraints, and engineering context rather than producing impressive one-off code.
Can Large Chinese LLMs Revive Intelligent Programming?
1. Evaluating a Model Requires More Than Benchmark Scores
To discuss whether Chinese large models can regain competitiveness, we first need to clarify what is being evaluated. A model’s value is not reflected only in math problems, knowledge Q&A, or single-turn code-generation accuracy, nor is it equivalent to how many lines of code it can output at once. In real R&D work, whether a model can continuously understand context, identify implicit constraints, follow project conventions, and maintain design consistency across multiple rounds of revision is often more important than whether a single answer “looks correct.”
Many developers have had similar experiences: small-parameter models execute quickly and cost less under explicit instructions, and they are highly efficient for generating simple interfaces, data structures, and test samples. But when requirements are ambiguous or business rules are not written out one by one, they tend to complete the task in the most common way rather than continue reasoning along the developer’s actual design intent.
The advantage of large-parameter models is more evident in “understanding the task.” They do not merely complete instructions; they also infer the problem the user is really trying to solve by combining existing code, context, naming conventions, business goals, and potential risks. This ability cannot be measured simply by code length, but it directly determines communication costs and rework in complex projects.
2. Wish-Driven Programming Really Tests Intent Understanding
So-called wish-driven programming can be understood as a developer describing goals, constraints, and expected results in natural language, after which the model handles solution design, code implementation, and debugging iterations. Its core is not “writing fewer lines of code,” but freeing developers from mechanical coding so they can focus on goal definition, architectural judgment, and result acceptance.
However, this way of working has a prerequisite: the model must understand the difference between “goals” and “means.”
For example, a developer says, “Ensure archive operations are safe and avoid concurrency conflicts.” This sentence does not explicitly specify the lock object, lock granularity, lock holding time, or transaction boundary. An execution-oriented model may choose to lock the archive directory or file records because this matches the literal meaning and can pass some tests. However, what the developer may really care about is the consistency of business master data: archives are only subordinate information of master data, and all related operations should be exclusively controlled around the unique identifier of the master data.
Both approaches may “have a lock,” and both may pass simple tests, but their design implications are completely different:
- Locking subordinate records has a smaller impact scope, but it may not prevent master data from being deleted or modified by other transactions.
- Locking the master data identifier can uniformly constrain related operations and simplify concurrency control logic, but lock contention and transaction duration must be evaluated.
- Relying only on application-layer checks is simple to implement, but it may create race conditions in high-concurrency environments.
- Only by combining the lock mechanism, transaction boundaries, and data constraints can a complete safety solution be formed.
This type of problem shows that code-generation quality depends not only on whether the model can write a lock, but more on whether it can understand the dependency relationships between data and the developer’s overall design intent.
3. Small Models Suit Execution, Large Models Suit Collaborative Design
Models of different scales do not have absolute advantages or disadvantages. It is more appropriate to divide usage scenarios by “task type.”
1. Advantages of Small-Parameter Models
Small-parameter models usually feature fast responses, low invocation costs, and high throughput. They are suitable for work with clear boundaries and strong repetitiveness, such as:
- Generating basic controllers based on established interfaces;
- Converting data structures into entity classes or serialized objects;
- Supplementing regular unit tests;
- Generating field validation and formatting code;
- Writing query statements according to explicit rules;
- Explaining local functions and simple errors;
- Performing code renaming, formatting adjustments, and template-based refactoring.
The common characteristics of these tasks are clear input, well-defined output boundaries, and limited business judgment. As long as the prompt is specific enough, small-parameter models can achieve high productivity.
2. Advantages of Large-Parameter Models
Large-parameter models are better suited to tasks such as:
- Extracting real business goals from natural language;
- Participating in system architecture and module boundary design;
- Analyzing implicit concurrency, permission, and consistency risks;
- Maintaining design coherence across multi-file and multi-module contexts;
- Comparing the long-term maintenance costs of multiple solutions;
- Identifying contradictions and omissions in requirements;
- Adjusting implementation according to team conventions rather than blindly pursuing a so-called optimal solution;
- Summarizing and critically analyzing existing comments, plans, or code.
In formal projects, the optimal solution is not necessarily an acceptable engineering solution. An algorithm may have higher performance but introduce complex abstractions; a database design may be more flexible but not fit the maintenance habits of the existing team; a refactoring plan may look advanced but increase migration risk. The model must understand “why this is done,” not just judge whether there is a more elegant way to write it.
4. Cost Comparison Should Not Rely Only on Call Counts
Many people evaluate models by comparing package quotas, call counts, or per-response prices. But for complex R&D tasks, a more reasonable metric is “the total cost of completing one effective task.”
Total cost includes at least the following parts:
- Model invocation cost: resources consumed by input context, output content, and repeated revisions.
- Human clarification cost: time developers spend re-explaining requirements and adding constraints after the model misunderstands them.
- Verification cost: time spent running tests, checking boundary conditions, and reviewing code.
- Rework cost: modifications that may expand in scope after a wrong solution enters subsequent modules.
- Maintenance cost: code that runs in the short term but has a chaotic structure will continue to create burdens later.
A lower-priced model may not ultimately be cheaper if every complex task requires multiple rounds of correction. Conversely, a large-parameter model that can understand context in one pass and reduce exploration in the wrong direction may be more cost-effective over the full project cycle, even if its per-call cost is higher.
Therefore, what is truly worth comparing is not “who can generate more content with the same quota,” but “who can deliver more acceptable outcomes with the same budget.”
5. Enterprise Projects Prioritize Compliance and Controllability
In government, state-owned enterprises, and industries with high data security requirements, model selection is also affected by compliance policies, deployment methods, data boundaries, and audit requirements. R&D teams cannot make decisions based only on public benchmarks or personal experience. They also need to confirm the following:
- Whether code and business data are allowed to be sent to external services;
- Whether deployment methods meet organizational requirements;
- Whether sensitive information entering the context can be controlled;
- Whether necessary invocation audit records are retained;
- Whether model access to specific directories and data can be restricted;
- Whether generated results go through human approval and automated testing;
- Whether responsibility and modification processes can be traced when errors occur.
This is also an important application space for Chinese models. For many organizations, a model must first meet security, compliance, and controllability requirements before pursuing extreme performance. As long as models continue to improve in complex requirement understanding, code collaboration, and adaptation to enterprise environments, they have the opportunity to become foundational tools in domestic R&D systems.
6. Recommended Approach: Strong Models Plan, Lightweight Models Execute
In practice, one model does not need to handle every task. A more reliable approach is to establish a layered collaboration workflow.
Step 1: Use a Strong Reasoning Model to Clarify Requirements
First ask the model to output goals, scope, key entities, constraints, exception scenarios, and acceptance criteria, rather than immediately generating code. For ambiguous areas, require the model to proactively list questions.
Step 2: Form a Reviewable Technical Plan
The plan should at least include module boundaries, data flow, transaction boundaries, permission control, concurrency strategy, failure handling, and testing focus. Developers review the plan before moving into implementation.
Step 3: Split the Plan into Clear Tasks
Break large tasks into subtasks such as interfaces, domain logic, data access, tests, and documentation. Each subtask should include inputs, outputs, prohibited items, and acceptance conditions.
Step 4: Use Low-Cost Models for Batch Execution
For local work that is already clear, faster and lower-cost models can complete it. This improves throughput and prevents large models from wasting resources on repetitive work.
Step 5: Use a Strong Model for Review
Finally, ask the strong model to review the result from the perspectives of requirement consistency, exception handling, security, maintainability, and test coverage. Its role is not simply to find syntax errors, but to judge whether the implementation deviates from the original design.
7. Prompts Should Describe a Constraint System, Not Just an Outcome
To help the model understand tasks more accurately, prompts should preferably include the following:
- Business goal: what problem the system ultimately needs to solve;
- Data relationships: which data is master data and which is subordinate data;
- Invariants: which conditions must never be violated under any circumstances;
- Permission boundaries: what operations different roles can perform;
- Concurrency requirements: which operations must be mutually exclusive;
- Transaction requirements: which steps must succeed or fail together;
- Compatibility requirements: which old interfaces and data must not be broken;
- Style requirements: which naming, layering, and exception-handling conventions to follow;
- Acceptance criteria: what result counts as complete;
- Prohibitions: which dependencies, abstractions, or behaviors must not be introduced.
Of course, writing detailed prompts does not mean relying entirely on prompts. A high-quality model should be able to detect contradictions in the description and proactively ask clarifying questions, rather than mechanically executing an instruction that may be flawed.
8. Conclusion: The Breakthrough for Chinese Models Is Understanding Projects
Whether Chinese large models can revive their glory depends not on copying a score on some benchmark, but on whether they can continuously improve the overall experience in real engineering scenarios.
For simple tasks, small-parameter models are already practical enough. For complex projects, the core value of large-parameter models lies in understanding goals, identifying implicit constraints, reducing wrong trial and error, and keeping implementation aligned with the developer’s design thinking. Future competition will not be only about parameter scale, but a comprehensive competition involving model reasoning, context management, code reliability, security and compliance, tool collaboration, and enterprise deployment.
Developers should also not treat models as “automatic programmers,” but as engineering collaborators with different capability levels: let strong models handle understanding and planning, let lightweight models handle execution and batch processing, and then form a closed loop through testing, review, and human decision-making. Only in this way can model intelligence truly translate into project delivery capability, rather than remaining at a single impressive-looking code generation.
