Large Language Models in Practice: Where Large Models Create Value, Where Small Models Fit, and the Breakthrough Path for Chinese LLMs

    Benchmark scores alone don't determine how useful a language model is in real development work. Drawing on hands-on experience with large-parameter and lightweight models, this article examines what actually shapes the developer experience—requirement understanding, task planning, constraint following, and iterative collaboration—and explains why "answering a test question correctly" is fundamentally different from "understanding a real project." It also covers how to split work between large and small models, a concrete concurrency/locking case study, the limits of "wish-driven programming," a layered human-AI collaboration workflow, and the capabilities Chinese LLMs need to build to earn broader industry recognition.

    1. Evaluating LLMs: Benchmark Scores Aren’t the Whole Story

    When people ask whether Chinese LLMs can rebuild their influence in the industry, the first thing to clarify is this: a model’s capability cannot be fully captured by a single leaderboard or a handful of test questions.

    For developers, the factors that genuinely shape the experience of using a model usually come down to four things:

    1. Requirement understanding: Can the model identify the problem a user actually wants to solve from scattered, incomplete descriptions?
    2. Complex task planning: Can it break a vague goal down into executable, verifiable steps?
    3. Constraint adherence: Can it stay consistent across multiple requirements spanning technology, business logic, security, performance, and compatibility?
    4. Sustained collaboration: Can it retain context and keep iterating along an established design direction?

    Some models perform almost identically on standardized benchmarks, yet feel completely different in real development. The reason is simple: “getting one question right” and “understanding a real project” are two different capabilities.

    In real projects, requirements are rarely written out as polished, structured prompts. A product manager may describe only the business goal, an architect may emphasize general principles, and developers care about edge cases and implementation details. The model must not only execute explicit instructions but also infer implicit constraints from context. This is why large-parameter models tend to deliver a noticeably better experience on complex tasks.

    2. The Core Value of Large Models: Lowering Communication and Trial-and-Error Costs

    The value of a large model isn’t just that it generates more code—it’s that it reduces the rework caused by “guessing the wrong direction.”

    When working with a small model, users often have to write extremely detailed prompts: what the database schema is, which fields must not be modified, how exceptions should be handled, what the concurrency rules are, what format the API responses must follow, and which approaches are explicitly off-limits. Miss one critical condition, and the model will complete the task based on its own default assumptions.

    This approach isn’t unusable, but it shifts a large chunk of analytical work back onto the user. On the surface you’re calling a model; in practice you’re acting as the requirements analyst, architect, and test designer, assembling every detail in advance.

    Large-parameter models show their advantage in being more likely to extract implicit intent from context. For example, if a user says “implement a secure archive operation flow,” the model shouldn’t just interpret that as “add a lock.” It should ask follow-up questions:

    • How are archives related to the business data?
    • What is the minimum granularity of concurrent operations?
    • Can deletion and update happen at the same time?
    • How is the lock’s lifecycle managed?
    • Does a failed operation require a rollback?
    • How do we prevent dirty reads and inconsistent states under multi-user access?

    Of course, large models aren’t infallible either. They are simply more likely to proactively raise questions, identify risks, and propose multiple options. The final design still requires developer confirmation—especially when data consistency, access control, and critical business flows are involved. A model’s inference must never be treated as ground truth about the system.

    3. Small Models Execute; Large Models Understand and Design

    Models of different sizes aren’t in a simple replacement relationship. A more sensible approach is to divide work by task type.

    3.1 Small models are suited for standardized work

    When a task has clear boundaries and fixed inputs and outputs, small models usually offer excellent cost-effectiveness. For example:

    • Generating data transfer objects from a defined format;
    • Writing simple CRUD code;
    • Producing field comments and API documentation;
    • Generating routine test data;
    • Performing log format conversion;
    • Doing localized code refactoring;
    • Extracting text according to explicit rules.

    The common trait of these tasks is that the goal is clear, ambiguity is low, and verification is cheap. As long as the prompt provides the necessary templates, a small model can quickly handle large volumes of repetitive work.

    3.2 Large models are suited for analysis and decision support

    When a task involves multiple layers of context, complex constraints, or implicit goals, large models are far more valuable. For example:

    • Distilling system boundaries from business descriptions;
    • Weighing trade-offs among several technical options;
    • Analyzing concurrency, transactions, and data consistency;
    • Assessing potential risks in legacy code;
    • Designing cross-module refactoring plans;
    • Turning vague requirements into acceptance criteria;
    • Explaining the key points, reasoning, and applicable scope of an argument.

    You can think of the two as an “executor” versus an “analytical assistant.” The former excels at following instructions to get work done; the latter is better at understanding why something should be done, what should come first, and where things might be missing.

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

    Suppose a system has two kinds of objects: business data, and archive files attached to that business data. To ensure safe operations, you need an exclusive lock in concurrent scenarios.

    If the requirement doesn’t explicitly state “lock on the primary key of the business data,” a model may, based on its own interpretation, lock the archive directory or a folder identifier instead. Such an implementation isn’t necessarily unusable—it may even pass existing tests—but it can diverge from the original design.

    Correct analysis should start by clarifying the object relationships:

    1. Business Data
    2. ├── Basic attributes
    3. ├── Status information
    4. └── Associated archives
    5. ├── File records
    6. └── Storage metadata

    If archive operations fundamentally depend on the state of the business data, then locking should be built around the business data rather than around a folder. The reasons:

    1. Preventing concurrent deletion of business data
      While a background task is processing archives, another user shouldn’t be able to delete the corresponding business data at the same time.

    2. Simplifying transaction boundaries
      Locking around the core business data lets related archive operations share the same state checks.

    3. Reducing logic fragmentation
      If folders, files, and data are locked separately, the code can easily end up with inconsistent lock ordering.

    4. Making future extension easier
      When attachments, approval records, or operation logs are added later, they can plug into the same concurrency-control strategy for the same business object.

    This case shows that code that “runs” is not the same as a design that is “correct.” If a model focuses only on local implementation, it may quickly deliver executable code without ever understanding what the system’s real concurrency-control target is.

    5. “Wish-Driven Programming” Boosts Efficiency but Can’t Replace Engineering Design

    Natural-language-driven development is often described as “wish-driven programming”: the developer describes the desired outcome, and the model generates the implementation. This approach is highly efficient for prototyping, page scaffolding, and routine feature development—but real projects must also honor a large set of implicit contracts.

    These contracts might include:

    • Existing interfaces cannot be changed;
    • Database fields must remain compatible with historical versions;
    • Certain exceptions must return specific error codes;
    • Code style must follow team conventions;
    • Critical operations must keep audit records;
    • Some seemingly better solutions are off-limits because they introduce extra dependencies;
    • Performance, maintainability, and migration cost must be evaluated together.

    So project development is not as simple as “have the model make the feature work.” It’s about having the model implement within an established approach and a fixed set of constraints.

    Sometimes a model proposes a more advanced architecture, but that doesn’t mean the project should adopt it. A new approach might be theoretically faster while raising the team’s learning curve; an abstraction might reduce duplicated code while hurting readability for ordinary maintainers. In enterprise systems, stability, clarity, and maintainability usually matter more than局部 technical sophistication.

    6. Designing a More Effective Human-AI Collaboration Workflow

    To balance efficiency and quality, you can adopt a layered collaboration approach.

    Step 1: Have a large model clarify the goal

    Don’t rush to have the model write code. First, have it answer:

    • What is the real goal of the current requirement?
    • Which information is already explicit?
    • Where is the ambiguity?
    • What risks might be involved?
    • What business rules need to be added?

    The point of this step is to establish a shared understanding.

    Step 2: Have the model propose options

    Ask the model for multiple candidate solutions, and have it explain the differences among them in complexity, performance, maintainability, and risk. Don’t settle for the single answer that “looks most reasonable.”

    Step 3: The developer confirms the boundaries

    The developer needs to decide which suggestions can be adopted and which must be ruled out, and to add internal project constraints. At this point you can produce a short design contract to serve as the basis for subsequent code generation.

    Step 4: Hand repetitive work to an execution-oriented model

    Once the architecture, interfaces, and data relationships are settled, use a lighter model to generate boilerplate code, test samples, documentation, and local implementations—this significantly reduces cost.

    Step 5: Perform independent verification

    Code generated by models must go through:

    • Unit tests;
    • Integration tests;
    • Concurrency tests;
    • Permission tests;
    • Exception-path tests;
    • Data rollback tests;
    • Manual code review.

    Features involving locks, transactions, permissions, and data deletion, in particular, cannot be verified only along the happy path.

    7. What Chinese LLMs Really Need to Break Through

    If Chinese LLMs want to regain stronger industry recognition, the focus shouldn’t be chasing a particular leaderboard ranking. They need to steadily improve the following capabilities:

    1. Complex context understanding
      Handling long documents, multiple roles, multiple constraints, and cross-module relationships.

    2. Stable task planning
      Not just producing answers, but delivering clear, executable, checkable steps.

    3. Understanding of Chinese-language business context
      Accurately recognizing the implicit rules in enterprise management, approvals, archives, permissions, and data governance.

    4. Reliable software engineering capability
      Not just generating local code, but respecting existing architecture, interface contracts, and historical compatibility.

    5. Stronger security and compliance capabilities
      Meeting enterprise requirements for data isolation, access control, auditing, and deployment options.

    6. A sensible cost structure
      Using powerful models for complex tasks and lightweight models for repetitive ones, forming a tiered invocation system.

    Conclusion

    Evaluating a large model means asking more than “can it write code?” You also need to ask whether it understands requirements, identifies implicit constraints, and can steadily advance along the developer’s design direction.

    Lightweight models can significantly improve execution efficiency, while large-parameter models are better suited for understanding, analysis, and solution reasoning. The mature development model of the future won’t rely entirely on one kind of model. Instead, it will be a collaboration system in which strong models do the thinking, lightweight models do the executing, and engineering processes do the verifying.

    Whether Chinese LLMs can earn broader recognition ultimately depends on achieving balance among complex requirement understanding, enterprise-grade engineering practice, security and compliance, and cost. For developers, the most important thing isn’t blindly chasing a particular model name—it’s choosing the right model for each type of task and always keeping a critical line of defense: human review and engineering validation.