Testing Chinese Open-Source LLMs on Frontend Generation: Capabilities, Gaps, and Value
This article presents a project-based evaluation of Chinese open-source large language models on frontend generation tasks. Using a realistic requirements document covering login, list, and form pages, it analyzes how well the models handle page structure, interactions, business rules, and cross-page consistency, compares them with leading international models, and discusses the broader value of open-source AI. It also provides a practical workflow for using LLMs effectively in frontend projects.
Testing Chinese Open-Source LLMs on Frontend Generation: Capabilities, Gaps, and Value
In recent years, large language models (LLMs) have made significant progress in code generation and frontend development. Given a page requirements document, a model can now generate component code, organize directory structures, add styles, configure routing, and even output a complete project that can be accessed directly. Compared with the earlier stage where models could only produce scattered code snippets, today’s intelligent coding tools have begun to participate in real software delivery workflows.
However, a page that “runs” is not the same as a project that “meets requirements.” In real-world development, what actually consumes time is rarely creating a button or scaffolding a page. It is understanding business rules, handling field relationships, implementing edge cases, and keeping interaction logic consistent across multiple pages. Therefore, evaluating a model’s frontend capability cannot rely on visual output alone; it requires examining whether the model has accurately understood the requirements document.
This article analyzes the performance of Chinese open-source LLMs in frontend generation scenarios based on a real project-style test. It further discusses the capability gap between these models and leading international models, as well as what their open-source nature means for the development of AI.
1. Test Methodology: From “Generating Pages” to “Completing a Project”
This test did not use simple single-page prompts. Instead, it used a relatively complete frontend requirements document covering a login page, a product list page, a form page, filter conditions, field validation, and several interaction rules. The model was required to deliver an accessible frontend project based on this document.
This approach is closer to real enterprise needs, because actual development is rarely “write me a card component.” Instead, the system is expected to:
- Identify page hierarchy and routing relationships;
- Understand the operation entry points for different roles;
- Distinguish display fields, editable fields, and read-only fields;
- Handle interactions such as filtering, pagination, submission, and cancellation;
- Validate required fields, formats, and field dependencies;
- Maintain consistent visual and interaction styles across multiple pages.
During the test, the model completed project initialization relatively quickly and generated directly accessible pages, which shows that current open-source models already possess solid engineering organization capabilities. However, as the requirements moved from static display into complex business logic, the model’s shortcomings gradually became visible.
2. Login Page: High Completion for Basic Structure and Common Interactions
The login page was the most stable part of the test. The requirements included a brand display area, a login form, and carousel content. The model essentially completed the page layout and implemented common elements such as input fields, buttons, and image switching.
This result shows that current models have developed mature knowledge representations for high-frequency, standardized page patterns. A login page typically has a well-defined structure:
- Left-right split or top-bottom layout;
- Basic inputs such as username and password;
- A login button and auxiliary links;
- Image or promotional content carousel;
- Mobile adaptation and basic responsive handling.
For this type of page, models can usually build the visual hierarchy quickly from a text description and generate code with basic usability. Even though production readiness still requires API integration, error messages, permission checks, and security policies, the output already has considerable reference value as a prototype or first version.
That said, success on a login page does not prove full product development capability. This type of page has a highly fixed structure with little ambiguity, so a model can complete most of the work simply by applying common templates.
3. List Page: Deviations Emerge When Moving from Visual Replication to Business Understanding
The list page was where problems concentrated in this test. The main page structure was present—including the title area, data table, and action entries—but the filter conditions explicitly stated in the requirements document were not fully implemented.
This type of problem is representative. A model can usually recognize that “a list is needed here” and “an action button should go here,” but it may not accurately understand the relationship between filter conditions and data display. For example, the following requirements demand strong business analysis ability:
- Which fields require exact matching and which support fuzzy search;
- Whether a date range includes the start and end dates;
- Whether multiple filters are combined with AND or OR logic;
- Whether pagination should reset when filters change;
- Whether clearing filters should automatically trigger a new query;
- Whether query conditions should persist after a page refresh;
- What states to display for empty data, loading, and request failures.
If the model only completes the table framework while omitting the filter logic, the project may look “finished” while remaining far from usable.
This highlights a key point: frontend generation capability can be divided into at least three levels.
The first level is visual structure generation—building the page layout and component appearance.
The second level is interaction behavior generation—implementing basic actions such as clicking, typing, switching, and submitting.
The third level is business rule generation—understanding the relationships between conditions and making data flow, state management, and page behavior conform to real business logic.
Many current models perform well at the first two levels, but at the third level they still require developers to break down, verify, and supplement the output.
4. Form Page: Complex Field Relationships Are the Model’s Main Challenge
Form pages place higher demands on models, because a form is not simply a collection of input fields—it is an interactive system involving state, constraints, and workflows.
In this test, the generated form displayed and ran correctly, but some fields, validation rules, and interaction details were not fully implemented according to the requirements document. Common issues included:
- Individual fields missing or inconsistently named;
- Not all required fields configured with validation;
- Incomplete format constraints for numeric, date, and text fields;
- Related fields failing to update when a dependent field changed;
- Edit mode and create mode sharing the same logic;
- User input not preserved after a failed submission;
- Error messages unclear in position or content.
The difficulty of complex forms lies in the fact that a form is essentially a state machine. Whether a field is editable, visible, or required often depends on the user’s current selection. For example, selecting a certain product type may require displaying additional configuration options; selecting a certain status may make some fields read-only; and an amount exceeding a threshold may trigger an extra confirmation step.
If the requirements document describes everything in natural language without listing field tables, state relationships, and validation matrices, the model can easily miss hidden conditions. Therefore, when using intelligent coding tools to generate forms, it is best to express requirements in a structured way, for example:
| Field | Type | Required | Editable Condition | Validation Rule |
|---|---|---|---|---|
| Name | Text | Yes | Create and edit | Length limit |
| Type | Dropdown | Yes | Create only | Must be a preset value |
| Quantity | Number | Yes | When type condition is met | Must be greater than zero |
| Remarks | Multiline text | No | Always editable | Length limit |
The clearer the structure, the less likely the model is to misinterpret “business constraints” as ordinary page descriptions.
5. Visual Quality: Engineering Usability Does Not Equal Product Maturity
From an overall visual perspective, the generated pages showed a reasonable degree of completeness, with acceptable layout and color schemes—clearly better than ad-hoc prototypes with no design standards. However, compared with a mature design system, several shortcomings remained:
- Insufficient page hierarchy;
- Inconsistent spacing and font sizes;
- Unclear primary/secondary relationships among action buttons;
- Inadequate design for empty, error, and loading states;
- Visual language not fully consistent across pages;
- Readability of dense content areas still requiring manual adjustment.
These results can be summarized as “engineering-usable, but not necessarily impressive.” Models are good at generating interfaces that follow common patterns, but they do not necessarily establish a complete product design language on their own.
Therefore, enterprises should not treat model output as a final design. A more reasonable approach is to let the model build the page skeleton and basic interactions first, then have designers or frontend engineers refine colors, spacing, responsive rules, and state feedback.
6. The Gap with Leading International Models Lies Mainly in Depth of Understanding
Based on comparisons on similar tasks, the gap between Chinese open-source models and leading international general-purpose models in basic page generation has narrowed significantly. Completion quality on standard pages such as login pages is now close, indicating that Chinese models are already highly competitive in code organization, common component understanding, and page layout generation.
The remaining gap is concentrated in the following areas:
First, long-document comprehension. When a requirements document is long, with many pages and interrelated rules, whether the model can consistently retain context directly affects the final result.
Second, implicit rule extraction. Strong models do not just execute explicit instructions; they also identify implicit state transitions, boundary conditions, and exception flows in the requirements.
Third, cross-page consistency. Real projects require list, detail, and edit pages to share field definitions, state logic, and interaction conventions. Some models perform well on single-page tasks but produce inconsistent naming and duplicated logic when coordinating across pages.
Fourth, generation speed and stability. Complex projects require longer reasoning and generation times. Unstable responses, queuing, or large variance across multiple generations all degrade the development experience.
Fifth, self-verification ability. A high-quality model should proactively check for omissions and point out unimplemented requirements, rather than simply outputting code that looks complete.
7. The Significance of Open Source for AI Development
The value of open-weight or open-ecosystem models lies not only in performance comparisons with a particular international model, but more importantly in lowering the barrier for developers, research institutions, and enterprises to work with large models.
First, open source drives local technology iteration. Developers can fine-tune, evaluate, and optimize models, building applications better suited to specific languages, industry terminology, and local business scenarios.
Second, open source strengthens technical controllability. When handling internal code, business documents, and sensitive data, enterprises can choose deployment approaches that match their security requirements, reducing dependence on any single external service.
Third, open source helps form a complete development ecosystem. The model itself is only infrastructure; around it, evaluation datasets, inference frameworks, data governance, intelligent coding tools, and enterprise application platforms are all needed. An open ecosystem can attract more participants to improve these components together.
Finally, open-source models promote capability transparency. Through public testing, community feedback, and real project validation, both strengths and weaknesses of a model are discovered faster, avoiding judgments based solely on promotional metrics.
8. How to Use LLMs More Effectively for Frontend Projects
To improve the accuracy of generated results, a workflow of “requirements decomposition → staged generation → automated verification → manual acceptance” is recommended.
Step 1: Organize the requirements document. List pages, fields, states, APIs, validation rules, and exception cases separately, instead of mixing everything into one block of natural language.
Step 2: Generate in stages. First generate the directory structure and page skeleton, then implement basic interactions, and finally add complex validation and exception handling. Asking the model to complete everything at once easily leads to context loss.
Step 3: Build an acceptance checklist. Verify item by item whether pages are complete, fields are all present, filters work, form validation is accurate, and mobile rendering is usable.
Step 4: Ask the model to self-check. Have the model go through the original requirements and list what is “implemented, partially implemented, or not implemented.” This is more effective than simply asking it to “keep improving the page.”
Step 5: Keep human review in the loop. Code involving permissions, data security, monetary calculations, state transitions, and critical business rules must be verified by developers and cannot rely entirely on automatic generation.
Conclusion
Chinese open-source LLMs have evolved in frontend generation from “being able to write code” to “being able to scaffold projects,” but there is still a way to go before truly reliable intelligent software engineering. Currently, they perform well on standard pages, basic layouts, and common interactions, while complex filtering, form constraints, cross-page consistency, and understanding of implicit business rules still require human involvement.
This does not mean the models have limited value. On the contrary, they are already capable of handling large amounts of repetitive work and helping developers quickly produce prototypes, page skeletons, and basic logic. The focus of future competition will also shift from simply comparing code generation speed to comparing requirements understanding, engineering reliability, automated testing, and continuous maintenance capability.
For developers, the most reasonable positioning is not to let models fully replace engineers, but to treat them as intelligent collaborators that can understand requirements, generate first versions, assist with review, and accelerate iteration. For the AI industry as a whole, the continued progress of open-source models means that more technical capabilities can be validated, improved, and deployed by a broader developer community—pushing AI from model demonstrations toward real production environments.
