Front-End Generation with Open-Source LLMs from China: Practical Observations and Adoption Guidance
This article shares hands-on observations from using open-source large language models from China for front-end page generation in real projects. It does not provide benchmark results or model rankings. Instead, it examines common model behavior, reusable requirement templates, acceptance checklists, and a layered validation process that teams can use to establish their own evaluation and adoption criteria.
This article is not a benchmark report, and it does not rank models. It is based on practical experience using open-source models from China in front-end projects. It summarizes how these models commonly behave in page generation and provides requirement templates, acceptance checklists, and validation workflows that can be applied directly. If you need to introduce open-source models into a team, the methods described here can help you build your own evaluation criteria.
1. Define What You Are Evaluating
Many discussions stop at whether a model can write code. For developers, more useful questions are: Can the model understand requirements? Can it turn design notes into runnable pages? Can it preserve existing functionality after requirements change? Is the final deliverable easy to maintain?
Parameter size, benchmark scores, and launch-event demos only show what a model can do under specific conditions. They are distant from real projects. Evaluation should therefore begin with a concrete task and record every issue that appears during completion.
2. Test with a Complete Project, Not a Single Snippet
The output for a single button or component can be satisfying, but it only demonstrates local coding ability. A front-end application usually includes login, lists, details, forms, permissions, and state feedback. The model needs to remain consistent across these parts.
A product specification close to real work should include at least the following:
- Page structure and route relationships;
- Field names, data types, and display rules;
- Query, filter, and pagination logic;
- Required fields, format validation, and error messages for forms;
- State changes after create, edit, and delete operations;
- Display behavior for empty data, loading states, and request errors;
- Visual style, layout constraints, and responsive requirements.
Only by testing different models with the same specification can results be compared. During testing, keep prompts, runtime environment, and scoring criteria fixed, and save the code generated in each run for later review.
3. Basic Pages Are Usually Handled Well
Most mature AI coding models can quickly generate login pages, navigation bars, cards, data tables, and basic forms. These structures are common patterns, and models have seen many similar examples during training, so first-pass completeness is often high.
A page that displays correctly is not necessarily usable. For a login page, for example, the following items say more about quality:
- Does each input field provide clear error messages?
- Is an empty submission blocked before a request is sent?
- Does the password visibility button toggle state correctly?
- Is the user’s account preserved after a failed login?
- Can carousel content be switched manually?
- Is there horizontal overflow on mobile?
- Is the submit button disabled during submission to prevent duplicate requests?
Acceptance can score each item. The more items that pass, the closer the output is to a usable deliverable. If only the visual structure is complete while these interactions are missing, the result is closer to a prototype, and developers will need to add a large amount of logic.
4. List Pages Expose Gaps in Requirement Understanding
List pages are among the most common screens in enterprise back offices, and they are also easy to underestimate. They must handle filtering, pagination, sorting, batch actions, and state feedback at the same time.
In testing, common model problems are usually omissions rather than syntax errors. The specification lists three filter fields, but the generated result has only one search box. The document requires action buttons to change by status, but the result shows static buttons. The document requires pagination to be linked with query conditions, but the result contains two unrelated controls.
To reduce these omissions, write requirements as a table and record the following information for each filter field:
- Field name and data type;
- Allowed values and display labels;
- Default value;
- Whether pagination resets after a query;
- Whether filters are preserved when changing pages;
- How the page is displayed when there is no data;
- Whether retry is allowed after a request fails.
If the requirement only says “support filtering by status and time,” the model can only guess. The more complete the field information, the more likely the model is to build the correct state model.
5. Complex Forms Test Logic Modeling
Forms often reveal model capability more clearly than display pages. Field dependencies, conditional display, input validation, default values, submission states, and error recovery all need to be handled within a unified state model.
A typical form may include these rules:
- Selecting a certain type dynamically displays additional fields;
- After one field is filled, another field becomes required;
- A numeric field has a restricted value range;
- User-entered content is preserved after a failed submission;
- After a successful save, the user is redirected to the detail page;
- Existing data is automatically populated during editing.
Generating input fields only from field names can make a page look complete, but it will still require many changes in actual use. This is also a dividing line for current AI coding tools. Simple pages rely on component composition and are close to code completion. Complex pages require requirement parsing, state management, and workflow reasoning, placing much higher demands on the model.
6. Visual Quality and Engineering Usability
Interfaces generated by models usually have orderly layouts, safe colors, and consistent spacing, but they often lack hierarchy and brand character. For admin systems and internal tools, this conservative style is usually acceptable and sometimes easier to maintain.
For user-facing commercial products, designers still need to address the following:
- Page information hierarchy;
- Visual priority of primary actions;
- Copy and illustrations for empty and error states;
- Motion pacing;
- Mobile adaptation;
- Color and typography systems;
- Consistency of the same component across different pages.
If the team has visual regression testing tools, it can establish screenshot baselines for model-generated results and set pixel-difference thresholds. Pages that exceed the threshold should go to manual review.
7. Speed, Stability, and Delivery Cost
The value of a model is not limited to code quality. Queuing, response delays, context interruptions, and overly long generation processes all affect the efficiency of continuous development.
It is advisable to record the following metrics and specify how each is measured:
- First response time;
- Total time to complete a single page;
- Number of failures when generating multiple pages consecutively;
- Proportion of existing functionality retained after requirement changes;
- Ability to locate and fix problems after errors occur;
- Whether the generated project can install dependencies and run directly;
- Time spent on manual fixes.
When recording these metrics, also note the device, concurrency level, context length, sample size, and measurement period. Without this information, the numbers cannot be compared.
The last item is especially important. Fast generation does not necessarily mean high overall efficiency. If developers must repeatedly correct missing logic, a slower result with higher first-pass completeness may have a lower actual cost.
8. Practical Value of the Open-Source Ecosystem
Open source allows developers to validate models in more real-world scenarios. User feedback can reveal issues that benchmarks struggle to cover, which directly helps model iteration.
Around open-source models, code agents, knowledge bases, automated testing, project scaffolding, and internal enterprise development platforms will also gradually form. The model is only the base capability; workflows and toolchains determine how much value it can deliver within a team.
Open source also helps cultivate local talent. More developers can participate in fine-tuning, prompt design, data preparation, and application development. Teams can therefore understand model boundaries more clearly and accumulate experience internally.
9. Layered Validation Mechanism
Even when a model performs well, human review should be retained. The following five validation layers can serve as a starting point. Each layer needs a clear owner and pass criteria.
The first layer is static checks, including code formatting, type errors, dependency versions, and known security risks. The pass criterion is an error-free build and dependencies that can be installed normally.
The second layer is functional testing, covering page navigation, form validation, filter conditions, error handling, and permission control. The pass criterion is that all test cases pass.
The third layer is visual regression, comparing screenshots across versions. The pass criterion is that differences remain within a preset threshold.
The fourth layer is human acceptance, in which product, design, and development jointly confirm whether requirements have been fully implemented. The pass criterion is that every item on the acceptance checklist has a clear conclusion.
The fifth layer is maintenance testing. Simulate a requirement change and observe whether the model can complete the modification while preserving existing functionality. The pass criterion is that all existing test cases pass before and after the change.
10. Adoption Recommendations
Individual developers can first use models to build page skeletons, common components, and repetitive code, then add business rules, API integration, and error handling themselves.
Team projects should standardize directory structure, component conventions, naming rules, and testing requirements before introducing models. The clearer the project boundaries, the easier it is for generated content to fit into the existing codebase.
When comparing models, enterprise managers should calculate the full delivery cost, including waiting time, review time, fix time, deployment cost, and ongoing maintenance cost. Comparing only single-generation output can lead to misleading conclusions.
Below is a selection checklist that can be used directly:
- Can the model accurately convert a requirements document into a page list?
- Are field dependencies in complex forms fully implemented?
- Do existing functions continue to work after requirement changes?
- Can the generated project run in the team’s build environment?
- On average, how many dialogue turns are needed to fix one error?
- Do generated data and code meet the company’s security and compliance requirements?
As a next step, choose a real but small module, such as one list page plus one form page. Complete the test using the requirement template and validation layers above, record all data, and then decide whether to expand usage.
