Code and Visual Generation in Practice: Model Capabilities Improve, but Aesthetic Control Still Lags
This article evaluates a preview version of a new-generation general model on two engineering-oriented visual coding tasks: an interactive animated SVG and a code-rendered indoor scene with afternoon light. It examines runnability, completeness, maintainability, offline capability, visual consistency, and aesthetic control. The model can produce usable self-contained prototypes and handle animation controls and basic spatial relationships, but its procedural rendering and aesthetic judgment remain limited. The article also outlines a multi-stage evaluation process and practical recommendations for prompting, testing, and iteration.
As general-purpose large models continue to improve, competition is no longer limited to question answering, summarization, and code completion. For developers, a more important question is whether a model can turn a natural-language requirement into a runnable program and then go further—producing animation, 3D scenes, interactive interfaces, and visually expressive work.
A preview version of a new-generation general model has recently opened for testing. According to official information, this version focuses on strengthening basic world knowledge, multimodal perception, code generation, and agent capabilities. However, the model’s specific parameter scale, training-data composition, and complete benchmark results have not been disclosed. Relying only on promotional information therefore makes it difficult to judge its real level; reproducible engineering tasks are still needed for verification.
This article selects two representative test directions: generating an interactive animated SVG, and using code to draw a scene with light-and-shadow effects. The first mainly examines the model’s combined understanding of vector graphics, animation logic, and interactive control. The second is closer to procedural creation and can expose weaknesses in spatial structure, material expression, lighting calculation, and aesthetic control.
1. Evaluation Focus: From “Can Generate” to “Can Complete”
Traditional code evaluations usually focus on whether algorithm problems pass, whether functions run, and whether generated code meets syntax requirements. In real development, however, users often present a complete goal, such as:
- Generate an animated page that can be opened directly;
- Add pause, speed control, and theme switching to the work;
- Keep the program running without a network connection;
- Build a scene with spatial relationships based on a text description;
- Make the final result not only usable but also visually competent.
Such tasks involve requirement understanding, technical selection, code organization, error handling, and visual judgment at the same time. Even if a model can generate a large amount of code, that does not mean it can deliver a high-quality result. This test therefore does not only observe whether something was generated, but also focuses on the following indicators:
- Runnability: Can the code execute directly, and are there obvious syntax errors?
- Completeness: Are key elements, interaction buttons, and state logic all present?
- Maintainability: Is the code structure clear, and are variable naming and module division reasonable?
- Offline capability: Does it depend on external resources, and can it still work after the network is disconnected?
- Visual consistency: Do lighting, space, materials, and motion follow natural laws?
- Aesthetic control: Does the final work have clear composition, hierarchy, and style?
2. Test 1: Generating an Interactive Animated SVG
The task was to generate an animated SVG of “a pelican riding a bicycle by the sea.” On the surface, this task is relatively simple, but it actually contains multiple technical points that the model must handle together:
- Drawing basic shapes such as the character, vehicle, and coastline;
- Rotation animation for the bicycle tires;
- Dynamic changes in the character’s body and scarf;
- Horizontal movement or parallax effects for background elements;
- Pause and resume controls;
- Animation speed adjustment;
- Day and night visual themes;
- Independent page operation without external images or scripts.
From the actual generated result, the model was able to build a relatively complete self-contained SVG page. The image includes a character wearing a hat, a seaside background, and the main body of a bicycle. The wheels rotate continuously, and the scarf changes direction with the motion. More importantly, the generated result was not just a static image; it also included interactions such as pause, speed adjustment, and day/night switching.
This shows that the model has fairly good combined capabilities in the following areas.
2.1 Understanding the Hierarchical Structure of SVG
SVG is not a simple image format. It is a way to describe vector graphics based on a node tree. The model needs to split the character, vehicle, background, and decorative elements into different graphic groups and realize a composite image through grouping, transforms, and style control.
For example, a reasonable structure usually looks like this:
<svg viewBox="0 0 1000 600"><g id="background"><!-- sky, sea, beach --></g><g id="bicycle"><!-- frame, wheels, pedals --></g><g id="character"><!-- body, hat, scarf --></g><g id="controls"><!-- page interaction buttons --></g></svg>
This structure makes it easier to add animation and interaction later, and it also makes local modification easier for developers. The test result shows that the model is no longer limited to outputting scattered graphic code; it can organize elements according to the semantics of the scene.
2.2 Combining CSS Animation with Script Control
Using CSS animation alone can achieve looping motion, but supporting pause, speed adjustment, and state synchronization usually requires scripts as well. A more reasonable implementation approach is:
- Use CSS
transformto control wheel rotation; - Use animation classes or animation states to control pause;
- Adjust speed by modifying
animation-duration; - Use scripts to switch day and night themes;
- Manage page state uniformly through button events.
Although this implementation relies on basic front-end techniques, the difficulty for a large model is that it must satisfy visual effects and interaction logic at the same time. The work generated in the test supports dynamic speed adjustment, and the animation still runs after being adjusted to a higher speed, indicating that the model has some state-management capability.
2.3 Self-Contained Code Helps Prototype Delivery
The generated result can be saved separately as an SVG or HTML file and opened directly without a network connection. This is very important for prototype demonstrations, teaching examples, and internal verification.
A self-contained implementation usually means:
- No remote images are referenced;
- No third-party scripts are relied on;
- No additional build step is required;
- A single file can be sent directly;
- Review and secondary modification are convenient.
However, developers should still check whether there are hidden external resource references, such as fonts, images, script files, or network interfaces. For projects that need long-term maintenance, resources should also be further split, comments should be added, and compatibility should be verified across different browser environments.
3. Test 2: Drawing a Light-and-Shadow Scene with Code
The second task was to use programming technology familiar to the model to draw an indoor scene with an afternoon light-and-shadow atmosphere. The requirements included a room, window, wall, floor, furniture, and plants, with emphasis on diagonal sunlight shining in through the window.
Compared with the animated SVG, this task is clearly more difficult. It is not just about “drawing a few objects”; it also requires the model to establish a relatively credible spatial relationship and handle the following issues:
- Whether the light-source direction is clear;
- Whether shadows change with object shapes;
- Whether transitions from bright areas to dark areas are smooth;
- Whether walls, wooden floors, and plants have material differences;
- Whether foreground, midground, and background form layers;
- Whether the image has a realistic photographic or painterly feel.
In the test, the model used a solution based on browser graphics APIs to build the room and also attempted basic rendering with the CPU. Its advantage is that the implementation path is clear, a runnable scene can be generated quickly, and the diagonal light projected from the window has a certain sense of direction. The light passes over the furniture and lands at the lower part of the image, indicating that the model can understand basic occlusion and projection relationships.
However, there is still an obvious gap between the result and high-quality procedural rendering.
3.1 Light Direction Is Correct, but Transitions Are Not Natural Enough
The most easily observed part of the image is the light projected from the window. The model can generate a bright area and make light pass diagonally through the room, but the transition between bright and dark areas often lacks sufficient subtlety.
Real lighting usually has the following characteristics:
- Directly lit areas are brighter;
- Light edges are affected by scattering;
- Walls and floors produce indirect reflection;
- Shadows are not pure black but carry ambient-light color;
- Different materials have different reflection intensities for light.
If a program uses only simple rectangles, gradients, and semi-transparent overlays, it easily produces an effect where “a light patch is stuck onto the image,” rather than light truly illuminating the space.
3.2 Object Shapes Are Semantic, but Material Expression Is Weak
The model can generate recognizable objects such as walls, stools, plants, and floors, but these elements often remain at the stage of symbolic expression. For example:
- The wooden floor is just repeated lines;
- The potted plant consists of several simple geometric shapes;
- Lines at wall corners are too hard;
- Furniture lacks real thickness;
- The occlusion relationships among plant leaves are not natural enough.
This shows that the model can already understand “what should be in the scene,” but its grasp of “how these objects should be presented” is not yet deep enough. In other words, semantic generation capability is strong, while visual detail and aesthetic control remain limited.
3.3 Pure Code Drawing Places Higher Demands on Engineering Capability
If the goal is to generate a high-quality static image, the program needs to implement a more complete rendering process, including:
- Building a geometric model;
- Setting the camera and projection relationship;
- Defining light-source position and intensity;
- Calculating object surface normals;
- Performing shadow determination;
- Handling reflection, refraction, and indirect light;
- Outputting an anti-aliased image.
Even with a simplified solution, the occlusion relationship between light and objects must be considered at a minimum. Simply overlaying colors and transparency can quickly produce a result that “looks like light,” but it is difficult to form a real sense of space.
Therefore, the model’s shortcoming in this test is not entirely code errors. Rather, its generation strategy leans more toward quickly building a prototype than fully implementing a high-quality renderer.
4. Where the Gaps Are Compared with Frontier Models
From the test results, the model has reached a relatively high practical level in code generation and interactive prototyping, but there are still several obvious gaps in procedural visual creation.
4.1 Requirement Decomposition Is Acceptable, but Visual Planning Is Insufficient
The model can identify objects such as rooms, windows, floors, and plants, but it cannot necessarily complete full composition planning before generation. High-quality work usually first determines:
- The visual center of the image;
- The main direction of light;
- The ratio of foreground to background;
- The rhythm of light and dark;
- The warm-cool relationship among colors;
- The path along which the viewer’s gaze moves.
Without this step, the generated result easily becomes a stack of elements. Each object may look reasonable on its own, but the combination lacks overall unity.
4.2 Understanding of Physical Laws Has Not Been Fully Translated into Rendering Details
The model may know that “sunlight enters the room through the window,” but that does not mean it can accurately implement lighting. A real lighting effect requires handling the light source, surfaces, occlusion, and reflection at the same time.
Similarly, the model knows that wheels should rotate, but it does not necessarily automatically add motion blur, contact shadows, and ground feedback. This difference reflects the distance between language-level knowledge and graphics computation.
4.3 Aesthetic Evaluation and Self-Correction Capabilities Remain Limited
After the model’s first generated result “can run,” it often treats the task as complete. But a human designer would continue to check:
- Whether black lines are too heavy;
- Whether shadows are too dirty;
- Whether object proportions are unbalanced;
- Whether the visual focus is clear;
- Whether colors are too monotonous;
- Whether details are consistent with the theme.
If the model lacks active review and iteration capabilities, it is difficult for the generated result to move from “usable” to “excellent.”
5. How to Design a More Scientific Model Evaluation Process
For development teams, it is not advisable to look only at a single generation result. A more reliable method is to establish a multi-round evaluation process.
Phase 1: Functional Verification
Check whether the page can open, whether the animation runs, whether buttons take effect, and whether the code has obvious errors. This phase mainly judges the model’s basic delivery capability.
Phase 2: Robustness Verification
Change some requirements in the prompt, such as adjusting the canvas size, adding a character, modifying animation speed, or switching the color scheme, and observe whether the model can complete the modification without breaking existing functionality.
Phase 3: Maintainability Verification
Ask the model to explain the code structure and further add new features, such as an export button, keyboard shortcuts, or responsive layout. If the code structure is messy, the cost of subsequent modification will rise significantly.
Phase 4: Visual Quality Verification
Developers or designers score the result from aspects such as composition, color, lighting, hierarchy, and consistency. For graphics tasks, functional passing does not mean visual quality meets the standard.
Phase 5: Agentic Continuous Task Verification
Split the task into multiple steps and let the model first plan, then implement, test, fix, and summarize. This makes it possible to observe whether the model has the ability to continuously execute complex tasks, rather than only being good at one-shot output.
6. Practical Development Recommendations
If large models are used for code and visual prototype development, the following methods can be used to improve final quality.
First, prompts should not only describe the theme; they should also specify technical constraints. For example, specify canvas size, runtime environment, whether external resources are allowed, interaction features, animation duration, and output format.
Second, split complex goals into multiple stages. First ask the model to generate a static composition, then add animation, and finally add interaction and performance optimization. This is usually more stable than asking for “all functions completed” in one go.
Third, ask the model to provide a self-check list, including resource dependencies, browser compatibility, exception cases, and code structure. This can reduce hidden errors.
Finally, visual tasks should adopt a “generate—screenshot—evaluate—revise” loop. The model itself may not accurately judge image problems, but developers can provide specific feedback, such as “lower the opacity of wall-corner lines,” “expand the dark-area gradient,” or “reduce floor texture density,” so that the model can make targeted corrections.
Conclusion
Overall, the new-generation model has already shown strong capabilities in code generation, interactive SVG, and lightweight graphics prototyping. It is especially suitable for quickly validating ideas, producing demonstration pages, and building offline small tools. It can understand relatively complex interface requirements and integrate animation, buttons, and state control into a runnable result.
However, in pure code drawing, 3D spatial representation, and advanced visual aesthetics, the model still resembles a highly efficient prototype engineer rather than a mature graphics programmer or visual designer. It is good at turning requirements into “works that can run,” but human participation is still needed to polish those works into “credible, natural, and aesthetically valuable finished products.”
For enterprises and development teams, the reasonable positioning is not to completely replace engineers or designers, but to use the model as a collaboration tool for requirement decomposition, code scaffolding, repetitive modification, and rapid trial and error. Only by combining human review, automated testing, and necessary graphics algorithm optimization can its value in intelligent development and creative coding be truly unlocked.
