Code Generation with Chinese Open-Source LLMs: A Real-World Frontend Engineering Test
This article examines how Chinese open-source large language models perform when code generation moves from isolated snippets to real frontend project delivery. Using a multi-page management system requirement, it assesses models across syntax correctness, functional completeness, semantic understanding, and engineering delivery. It also discusses the relationship between generation speed and project quality, the practical value of open-source models, remaining technical gaps, and how developers can structure requirements and validation to use these models more effectively.
In recent years, Chinese large models have made clear progress in code generation, intelligent Q&A, and software development assistance. Open-source models with stronger reasoning and programming capabilities are no longer limited to completing a few lines of code. They are beginning to generate complete projects from natural-language requirements, including page structure, interaction logic, style files, and a runnable engineering setup.
However, there is still a considerable gap between “being able to generate code” and “being able to complete a real project.” Whether a model truly has engineering capability should not be judged only by whether it can produce a piece of code that looks correct. It should also be judged by whether it can understand a complete requirement, maintain consistency across multiple pages, handle complex state and validation logic, and ultimately deliver a project that can run, be tested, and be maintained.
Based on a real frontend requirement practice, this article discusses how Chinese open-source models perform in engineering development and analyzes what such models mean for the open-source ecosystem and the development of the AI industry.
I. Why Marketing Metrics Are Not Enough
When a model is released, it usually presents results for code capability, mathematical capability, reasoning capability, or comprehensive benchmarks. These metrics are useful for reference, but they are often obtained on standardized datasets and relatively well-defined tasks. They still differ from real development scenarios.
In actual projects, the requirements developers face usually have the following characteristics:
- Requirements come from natural-language documents and have context dependencies.
- Pages share common components and state.
- Different roles may see different fields and operations.
- Forms include conditional display, linked validation, and exception handling.
- There may be implicit relationships among design files, API descriptions, and business rules.
- The project must not only be “generatable,” but also easy to debug, extend, and deploy.
Therefore, evaluating a model’s programming capability requires observing at least four levels:
- Syntax correctness: Whether the code can be compiled or interpreted and executed.
- Functional completeness: Whether the functions listed in the requirement are actually implemented.
- Semantic understanding: Whether the model understands field relationships, business constraints, and interaction flows.
- Engineering delivery: Whether the project has a reasonable structure, runnability, and maintainability.
Among these, the latter three levels are often more important than raw code generation speed.
II. A Real Project Test: Observing Model Capability Through Page Generation
To avoid testing only with simple Q&A, one can prepare a small or medium-sized management system requirement containing multiple pages and ask the model to build a complete frontend project from the requirement document. The test content can include a login page, a data list page, a detail page, an edit form page, and basic state feedback.
This type of task can expose model problems more comprehensively because it tests visual layout, page organization, data processing, and interaction implementation at the same time.
1. Login Page: Basic Structure Is Usually Handled Well
A login page generally includes an account input, a password input, a verification code or auxiliary prompt, a login button, and possibly a promotional area or carousel area. For pages with a clear structure and relatively simple interactions, models can usually complete:
- The basic page layout;
- Rendering of form controls;
- Required-field prompts;
- Login button states;
- Basic error feedback;
- Simple image or content carousel.
From practical experience, open-source models already perform relatively well on this type of task. Even if the visual effect is not particularly strong, they can usually generate a runnable page, and developers only need to further adjust colors, spacing, and responsive details.
This shows that the model already has strong pattern-reuse capability. For common business pages, it can quickly apply mature implementation structures and significantly reduce the time needed to build a project from scratch.
However, success on a login page does not mean the model fully understands complex projects. Such pages usually have simple rules and few relationships between fields, making them relatively easy tasks.
2. List Page: Understanding Behavior Is Harder Than Building the Page
The list page is a more representative test scenario. It often includes a search box, multiple filter conditions, pagination, sorting, bulk operations, status tags, and detail entry points.
Many models can generate a list page that looks complete, but further inspection may reveal that filter conditions are only displayed statically and do not actually participate in data filtering; pagination buttons may not be connected to data state; and sorting controls may be decorative only.
The essence of this problem is not that the model “cannot write controls,” but that it has not fully understood the behavioral constraints in the requirement. For example, the requirement document may specify:
- After entering a keyword, search by name and ID at the same time;
- Status filtering and time-range filtering must work in combination;
- Clearing conditions restores the default data;
- Changing the page size recalculates the current page;
- A loading state is displayed during queries;
- An empty state is displayed when there are no results instead of a blank page.
If the model only identifies which components appear on the page but does not establish the relationship between those components and data state, the final output is merely “a page that looks like a list page,” not a truly usable list function.
Therefore, when evaluating a list page, one should not look only at the visual effect. Each item should be verified:
- Whether all filter items are present;
- Whether each filter item actually affects the results;
- Whether multiple conditions can be combined;
- Whether the reset logic is correct;
- Whether pagination, sorting, and query state are synchronized;
- Whether loading, exception, and empty-data states are complete.
This is also the weakness most likely to be exposed when many current models move from “code generation” to “application construction.”
3. Complex Forms: The Best Test of Requirement Restoration
Form pages are often harder than list pages because they contain many fields and business rules. A real form may involve:
- Required conditions for fields;
- Format validation for different field types;
- Linkage relationships between fields;
- Dynamically displaying other fields based on selected results;
- Numeric range and length limits;
- Differences between create and edit modes;
- Save, cancel, and draft states;
- Error location after submission failure.
Models can usually quickly generate basic controls such as inputs, selects, and date pickers, but they may not accurately implement the logical relationships between fields. For example, a field is displayed only when a previous field selects a specific value; the upper limit of a numeric field depends on another field; and an edit page needs to backfill existing data and restore linkage state. If these issues are not explicitly encoded, the page may open, but many boundary errors will appear in actual use.
Therefore, the evaluation focus for complex forms should shift from “whether controls are complete” to “whether rules are correct.” A verification checklist can be established, recording for each field:
- Display conditions;
- Input type;
- Default value;
- Validation conditions;
- Error prompts;
- Dependencies on other fields;
- Data format at submission.
This kind of structured check is more valuable than vaguely saying “the page is well completed,” and it can also help developers locate whether the model missed a requirement or the requirement document itself was unclear.
III. The Relationship Between Model Speed and Engineering Quality
In practical use, model response speed is also an important factor affecting experience. Generating a complete project may take a long time, especially when the model needs to repeatedly analyze file structures, create multiple pages, and fix errors.
However, speed cannot be evaluated in isolation. Quickly generating an incomplete project is not necessarily more valuable than a slightly slower result with more accurate functionality. A more reasonable evaluation should include:
- Time to first generation;
- First-run success rate;
- Manual repair time after generation;
- Number of missed requirements;
- Number of rework cycles;
- Maintainability of the final project.
If a model takes a long time for the first generation but requires fewer subsequent modifications, overall efficiency may still be high. Conversely, if a model generates quickly but misses a large amount of filtering, validation, and state logic, developers need to spend more time checking and rewriting, reducing the actual benefit.
In addition, service congestion, resource limits, and runtime environments may also affect response speed. Therefore, tests should distinguish model capability from service conditions as much as possible, avoiding attributing occasional queuing, network, or resource issues simply to model quality.
IV. The Real Value of Open-Source Attributes
The significance of open-source models is not just “free to use.” More importantly, they provide developers and enterprises with a technical foundation that is observable, adjustable, and extensible.
1. Lowering the Cost of Trial and Error
Closed-source services are usually accessible only through APIs, making it difficult for developers to understand the model’s behavioral boundaries on different tasks. Open-source models allow users to experiment locally or in private environments and study model performance in code generation, document understanding, and multi-turn modification.
For enterprises, this means they can first validate model value with small-scale projects and then decide whether to invest more resources, without relying entirely on a single service.
2. Promoting Optimization for Vertical Scenarios
General models can cover many scenarios, but enterprises often have specific code standards, component systems, and business terminology. Through fine-tuning, retrieval augmentation, prompt templates, and workflow orchestration, models can be made more suitable for specific projects.
For example, enterprises can provide:
- Internal component documentation;
- API definitions;
- Coding standards;
- Common error cases;
- Historical project structures;
- Test cases and acceptance criteria.
In this way, the model does not merely “generate a piece of code” but gradually becomes integrated into the enterprise development process.
3. Forming a Developer Ecosystem
Open-source models can attract developers to contribute data, tools, evaluation sets, and practical experience. As the number of users grows, model problems will be discovered more quickly, and adaptation solutions will become richer.
This ecosystem value is often not reflected by short-term metrics. Even if a model currently has shortcomings, as long as it has room for open improvement, it may grow quickly through community feedback and engineering practice.
4. Driving Compute and Infrastructure Development
The spread of open-source models will also drive the development of infrastructure such as inference services, model compression, hardware adaptation, container deployment, monitoring and alerting, and data security. The more complete the toolchain around models becomes, the easier it is for AI to move from the demonstration stage into production.
V. Areas Chinese Open-Source Models Still Need to Advance
From frontend project practice, Chinese open-source models already have strong basic coding capability. However, to further improve engineering usability, they still need to focus on optimizing the following areas.
1. Moving from Component Recognition to Business Modeling
Models need to understand not only which buttons are on a page, but also the state changes, permission restrictions, and business outcomes behind those buttons. Future work should focus on establishing more stable requirement parsing and task decomposition capabilities.
2. Strengthening Long-Context Consistency
When requirement documents are long and the number of pages is large, models can easily miss earlier constraints. Cross-file, cross-page, and cross-turn memory capabilities need to be improved to avoid contradictions between generated results.
3. Establishing an Automated Verification Loop
High-quality code generation should not stop at outputting code. It should include:
- Generate the project;
- Run it automatically;
- Execute static checks;
- Run test cases;
- Find errors;
- Fix them automatically;
- Verify again.
Only by forming such a closed loop can a model become closer to a true intelligent development assistant.
4. Improving Coverage of Boundary Conditions
Many models perform well on normal flows but tend to ignore empty data, duplicate submissions, network exceptions, insufficient permissions, out-of-range input, and state recovery. The reliability of enterprise software is often determined precisely by these boundary conditions.
VI. How Developers Can Use Open-Source Models More Efficiently
Model capability is not the only variable; the way requirements are expressed is also important. Developers can use the following methods to improve generation quality:
- First state the project goal and page list;
- Clarify the input, output, and state of each page;
- List fields, types, and validation rules in a table;
- Describe exception flows and empty states separately;
- Provide navigation relationships between pages;
- Ask the model to output an implementation plan before generating code;
- Generate in stages rather than completing all functions at once;
- Run and accept each page after it is completed;
- Use a test checklist to verify requirements item by item.
For complex projects, an iterative approach of “requirement decomposition—code generation—runtime verification—issue fixing” is more recommended than expecting the model to generate the final result in one pass.
VII. Conclusion: Benchmarking Is Not the Endpoint; Engineering Delivery Is the Key
The gap between Chinese open-source large models and advanced international models is no longer just about “whether they can write code.” It is increasingly reflected in depth of requirement understanding, restoration of complex interactions, consistency across long workflows, and automated verification capability.
From real projects, open-source models can already significantly reduce the cost of building basic pages and provide relatively high efficiency in common engineering scenarios. However, for complex lists, dynamic forms, and multi-page business workflows, developers still need to perform strict acceptance checks and manual corrections.
This does not diminish the value of open-source models. On the contrary, open models, data, and toolchains provide a foundation for continuous improvement. As long as evaluation methods move from “it looks runnable” to “requirements are complete, logic is correct, testable, and maintainable,” Chinese models can continue to improve through real engineering feedback.
For developers, the most important thing is not to blindly chase a model’s marketing results, but to establish evaluation standards suitable for their own projects. For the industry, the truly meaningful competition is not short-term generation speed, but whether a model can stably enter the development process and continuously create quantifiable engineering value.
