Evaluating Multimodal Models for Web Design Tasks: A Unified Testing and Assessment Method

    This article presents a practical method for evaluating multimodal models on real web design tasks rather than simple image recognition. Using a shared development environment, identical source assets, browser-based previews, and a one-round repair limit, it compares three models across data-driven exhibition and interaction-heavy tasks. The article examines first-version stability, runtime validation, repair ability, efficiency, cost, design originality, and engineering completeness, and proposes a reusable six-dimension scoring framework for development teams.

    After artificial intelligence models began entering design and development workflows at a rapid pace, whether a model can recognize images is no longer the only criterion for measuring multimodal capability. For real web design tasks, a model must process images, structured data, natural language requirements, and the state of a running page at the same time, and turn that information into executable interface code. More importantly, it must be able to preview the page in a browser and identify layout overflow, text truncation, hierarchy confusion, and interaction failures from desktop and mobile screenshots.

    Therefore, simply comparing what kind of mockup a model generates often fails to show its real engineering capability. A more valuable evaluation method is to place multiple design tasks in a completely identical environment and observe the model’s full process from requirement understanding and page construction to runtime validation and issue repair.

    1. Test Objective: From “Seeing” to “Completing”

    This test selected three types of models with visual understanding and code generation capabilities, referred to as Model A, Model B, and Model C. All three used the same page development environment, the same set of source assets, the same browser tools, and consistent task descriptions. Each task allowed only one round of repair to minimize the impact of human intervention on the results.

    The focus was not to determine whether a particular model was “smarter,” but to analyze the following engineering questions:

    1. Can the model correctly understand complex visual requirements?
    2. Can it translate design intent into a structurally sound, runnable page?
    3. Can it handle the relationships among data, images, animation, and interaction?
    4. Can it validate its own implementation through a browser?
    5. After discovering an issue, can it complete an effective repair within a limited number of attempts?
    6. How does it balance page quality, response speed, and resource consumption?

    From the final results, all three models completed the required tasks and reached an acceptable standard, but their strengths differed. Model C stood out in execution speed and resource cost, Model A was more stable in first-version completion, and Model B tended to build a complete product-like page but relied more heavily on browser validation.

    One point requires particular emphasis: a model generating a large amount of code does not mean it has truly completed the design task. Only when the page runs, interactions form a closed loop, the visual hierarchy meets requirements, and the layout remains stable at different sizes can the work be considered an effective delivery.

    2. The Importance of a Unified Test Environment

    If different models use different prompts, assets, runtime environments, or numbers of human repairs, the final results are difficult to compare fairly. To reduce interference, the test used the following unified conditions.

    1. Same Design Environment

    All models worked in the same version of the web design development environment, using the same directory structure, resource loading method, and preview mechanism. This avoided giving one model an extra advantage because it was more familiar with a particular framework or tool.

    2. Same Asset Inputs

    Test assets included structured data, map images, photography, text materials, and visual references. The models needed to read data and understand image content and brand atmosphere; they could not rely only on text descriptions to complete the page.

    3. Same Browser Capabilities

    All models could open the page, view runtime results, and use screenshots for analysis. The browser here was not a simple display tool but an important part of the model’s self-check. Many issues only appear after real rendering, for example:

    • page width exceeds the viewport;
    • text is truncated on small screens;
    • image proportions are distorted;
    • fixed-position elements cover content;
    • scroll areas cannot be triggered;
    • click areas do not align with visual positions;
    • dynamic data is not synchronized with page state.

    4. Limited Repair Count

    Each task provided only one repair opportunity. The purpose was to observe the reliability of the model’s first-version implementation and whether it could quickly locate the main issues under limited feedback. If unlimited modification were allowed, the final result might reflect the model’s number of trial-and-error attempts rather than its initial judgment capability.

    3. Task One: A Data-Driven Ocean Memory Exhibition

    The first task required building a scrolling ocean-themed exhibition. Inputs included multi-year environmental data, a world map, sea area materials, and natural landscape images. As users scroll down, the page needs to advance the timeline and narrative content in sync. When users click different sea areas, the page must also update the map state, related data, and ecological risk explanations.

    This type of task tests visual expression, data storytelling, and interaction design at the same time. The difficulties are mainly concentrated in three areas.

    First, the page cannot simply stack titles, images, and charts. Year changes must be linked to the user’s scrolling behavior, and data curves, explanatory text, and visual states must remain synchronized. Second, the map area needs recognizable interactive feedback so users clearly know which sea area is currently selected. Finally, the page must balance exhibition feel and readability; it cannot sacrifice information comprehension efficiency for visual impact.

    Model A: More Stable Above-the-Fold Performance

    Model A’s first screen had a strong editorial design feel. It placed a large title over a satellite image, establishing clear foreground, midground, and background layers with strong visual impact. The relationship among the title, supporting text, and image was relatively mature, and users could quickly understand the theme after entering the page.

    Its advantage was mainly that the first version had a relatively complete structure: the hero, timeline, data area, and map module had clear sections, and key content was not obviously missing. For tasks that require rapid delivery of a visual draft or a showcase page, this stability is important.

    The weakness was that visual expression was relatively dominant. When the large title, background image, and decorative elements appeared together, the contrast of some supporting information decreased. If further optimization is needed, the focus should be on adjusting the color relationship between text and background and controlling the number of decorative elements in the hero section.

    Model B: Restrained Information Organization, but Weaker Visual Memorability

    Model B adopted a more restrained design direction. A dark background, centered explanatory text, and a relatively orderly data layout gave the page a clear and quiet reading experience. For data display, this style can reduce visual noise and support continuous reading.

    Compared with other implementations, however, its first impression was not strong enough. Although the page was complete, it lacked a core visual symbol that could quickly establish theme memorability. For an exhibition-style webpage, arranging information neatly is not enough; it also needs to form distinctive recognition through title composition, image cropping, motion rhythm, or spatial whitespace.

    In addition, Model B relied more on browser feedback during implementation. Only after the page actually ran did it more fully discover some layout and interaction issues and repair them to reach an acceptable level. This shows strong closed-loop execution capability, but there is still room to improve first-version anticipation.

    Model C: High Completion and a Clear Speed Advantage

    Model C used a solution between the two styles in this task: the page retained important elements such as a giant English title, themed background image, and vertical depth markers, while avoiding excessive stacking of decoration. Overall completion was high, and the core visual structure and interaction modules were basically complete.

    From the execution process, Model C responded faster and consumed fewer resources. Under the conditions of this test, the total cost of completing the three tasks was approximately CNY 1.35, and the elapsed time was the shortest. However, this data only represents the result under this specific environment, task scale, and invocation method; it cannot be directly generalized into a fixed cost or absolute performance in all scenarios.

    4. From Single-Page Effect to a Complete Interaction Loop

    The real difficulty of a multimodal design task is not making an image look beautiful, but making design, code, and runtime results consistent with one another.

    A complete loop usually includes the following steps:

    1. Read requirements and assets
    2. ↓
    3. Extract information hierarchy and interaction states
    4. ↓
    5. Generate page structure and styles
    6. ↓
    7. Launch page and preview in browser
    8. ↓
    9. Check desktop and mobile screenshots
    10. ↓
    11. Locate overflow, occlusion, truncation, and state errors
    12. ↓
    13. Modify code and re-validate

    There is a clear difference between the third and fourth steps. Code that “looks correct” does not mean the browser rendering result is correct. CSS layout may be affected by fonts, image proportions, viewport size, and content length; interaction logic may also fail because of event binding locations or inappropriate state management.

    Therefore, when evaluating a model, “whether it actively validates the page” should be treated as an important indicator. If a model only generates files, does not open the page, does not view screenshots, and does not simulate clicks, then it is closer to a code completion tool than an intelligent collaborator capable of independently completing design implementation.

    5. Capability Differences Among the Three Models

    Based on the performance across the three tasks, the differences can be summarized along the following dimensions.

    1. First-Version Stability

    Model A had the most stable first-version structure. It could usually establish a clear visual mainline earlier and reduce large-scale rework later. It is better suited to tasks with high requirements for display effect, hero quality, and visual completeness.

    2. Runtime Validation Capability

    Model B relied more on the browser closed loop. It might not accurately predict all issues during the first generation, but it could gradually correct them through page runtime and screenshot feedback. This capability is valuable for complex product pages, because real development inherently requires continuous validation.

    3. Execution Efficiency and Cost

    Model C performed best in speed and resource consumption. On the premise that completion meets requirements, it could deliver results relatively quickly. For scenarios involving batch page generation, rapid prototyping, or multi-round solution exploration, this advantage is obvious.

    4. Design Originality

    Visual originality cannot be judged only by whether colors are unique. It also requires examining whether title composition, spatial relationships, image usage, and interaction narrative form a unified language. Model A was more prominent in first-screen visual impact, Model B was more restrained, and Model C achieved a relatively balanced result between completion and expressiveness.

    5. Engineering Completeness

    Engineering completeness includes whether resources load correctly, whether components can be reused, whether interaction states form a closed loop, whether mobile adaptation works, and whether errors are easy to repair. These aspects cannot be fully evaluated from static screenshots alone; they must be checked together with the runtime process and code structure.

    6. Building Reusable Evaluation Metrics

    To make similar tests more comparable, the final result can be divided into six dimensions:

    • Requirement understanding: 20%
      Whether the model accurately extracts the theme, content hierarchy, page structure, and interaction requirements.

    • Visual quality: 20%
      Includes composition, typography, color, font hierarchy, image usage, and overall style consistency.

    • Interaction completion: 20%
      Checks whether scrolling, clicking, filtering, state switching, and data linkage are truly usable.

    • Responsive adaptation: 15%
      Checks whether desktop, tablet, and mobile views have overflow, occlusion, or reduced readability.

    • Self-check and repair: 15%
      Observes whether the model can proactively discover issues and complete effective corrections within a limited number of attempts.

    • Efficiency and cost: 10%
      Comprehensively considers elapsed time, invocation count, resource consumption, and degree of human intervention.

    This scoring method can avoid one-sided conclusions based only on screenshots and can also give different models more accurate evaluations in the directions where they excel.

    7. Practical Implications for Development Teams

    First, do not treat multimodal models as simple image recognizers. Their value lies in connecting visual understanding, text analysis, code generation, and runtime validation. Only by placing these capabilities in the same workflow can they deliver real productivity.

    Second, prompts should explicitly describe interaction states, not just page style. For example, instead of saying “make a premium-feeling ocean page,” it is better to specify which text, curves, and map states need to update at a certain scroll stage, and which content must change after clicking different areas.

    Third, structured assets should be provided whenever possible. The clearer the data fields, image purposes, content hierarchy, and page constraints, the easier it is for the model to generate stable results. For complex tasks, the model can also be asked to first output the page structure and a state checklist before moving into coding.

    Fourth, browser validation must become a standard step. Design tasks cannot rely only on static code review; at minimum, the hero section, key interaction states, long content areas, and mobile layout should be checked.

    Fifth, model selection should be based on task type. When pursuing first-version visual effects, a solution with higher first-version stability can be prioritized; when rapid batch generation is needed, execution speed and resource cost should be considered; for complex products, browser closed-loop capability, state management, and repair ability should be key considerations.

    Conclusion

    This test shows that the differences among multimodal models are not only about “whose generated page looks better,” but also about different stages of the complete workflow: some are good at first-version composition, some are good at repair after runtime, and some are good at delivering results quickly at lower cost.

    For developers and design teams, a more reliable evaluation method should be: unify the environment, unify the assets, limit human intervention, and fully record the model’s entire process from understanding requirements to validating the page. Only in this way can we judge whether a model truly has the ability to turn visual intent into a runnable product.

    In the future, competition among multimodal intelligent tools will also shift from “whether it can generate a page” to “whether it can reliably complete a page.” Whoever can more accurately understand information hierarchy, more proactively discover runtime issues, and continuously deliver high-quality results under limited resources will be closer to a truly intelligent design and development assistant.