Next-Gen LLM Coding in Practice: From 3D Web Pages to Game Prototypes

A New Yardstick for Judging LLMs: From Benchmark Scores to Visible Works

Evaluating a new model used to mean checking benchmark scores and leaderboard rankings. But scores only tell you how a model performs “on the test set”—they rarely answer the question developers care about most: can it turn my idea into something that actually runs?

A recent wave of community projects offers a more direct answer. Some developers built open-world-style game scenes complete with streets, vehicles, and running characters; others put a foldable phone’s 3D model on a web page where it can be dragged open and closed; still others showed a robotic hand disassembled step by step into more than two thousand parts, with cloth fluttering naturally in the wind. What these works have in common: they are end-to-end, runnable, and interactive—not screenshots or concept art, but real programs you can open in a browser and play with.

From a technical standpoint, these demos carry more information than scores, for three reasons:

• Verifiability: The artifacts run directly, so quality is immediately obvious—there is no room for benchmark gaming;
• Task complexity: The combination of 3D rendering, physics simulation, and interaction logic stresses code length, architecture organization, and context length;
• Cost transparency: The authors published time spent, token consumption, and dollar cost, putting “capability” and “price” at the same table for the first time.

Highlight 1: End-to-End Generation of Complex 3D Interactions

What Makes These Tasks Hard

Browser-based 3D applications are quintessential “composite” programming tasks that require a model to handle multiple layers of knowledge at once:

• 3D math: coordinate transforms, matrix operations, camera projection;
• The rendering pipeline: scene graph organization, materials and lighting, animation loops, asynchronous asset loading;
• Interaction logic: keyboard and mouse events, state management, coupling between the UI and the 3D scene;
• Performance constraints: in a browser environment, frame rate, memory, and draw call counts all have hard ceilings.

A failure in any one layer makes the visuals blurry or stuttery. Producing such programs reliably signals that a model’s ability to organize long code files and anticipate runtime behavior has stepped up a level.

Two Representative Cases

Case 1: An open-world-style game prototype. A developer with early access used the new generation of models to build a game demo with an open-world feel—streets, vehicles, and running characters that instantly create a familiar atmosphere. According to their write-up, the project took about 10 hours and roughly 4 million tokens, at a total cost of $51.98; they estimated that completing the same amount of work with other flagship models could run to the order of $500 (a personal estimate, for reference only). For game prototype validation, getting an interactive version for a few dozen dollars and a few evenings is already a compelling return on investment.

Case 2: Modeling a foldable phone and making it interactive on the web. The same developer had the model first create the foldable phone’s form in 3D modeling software, then export it into an interactive web page: the phone can be opened and folded, and the screen content changes with its form. The whole process took about 1.5 hours and $12.50. The value of this case is that it connects the full pipeline of “modeling—export—web integration—interaction,” a production-ready pattern for product showcases and creative proposals.

A Minimal Skeleton for Reference

// Pseudocode: minimal skeleton of a browser-based 3D scene
const scene = createScene();
const camera = createPerspectiveCamera({ fov: 60 });
const renderer = createWebGLRenderer(canvas);
function animate() {
  requestAnimationFrame(animate);
  const dt = clock.getDelta();
  updatePhysics(dt);      // cloth, rigid bodies, and other physics simulation
  handleInput();          // keyboard / mouse interaction
  updateAnimations(dt);   // character and scene animations
  renderer.render(scene, camera);
}
animate();

Real projects are far more complex than this skeleton, but the structure is the same: what the model generates is often not scattered snippets but a complete codebase that includes asset management, an update loop, and event handling.

Highlight 2: Long-Horizon Planning and “Self-Repair”

Complex works almost never succeed in a single shot. What really separates models is how they behave in the “plan → generate → run → error → fix” loop:

• Task decomposition: breaking “build a game prototype” into subtasks such as scene setup, character control, and collision detection, then tackling them one by one;
• Multi-file project organization: no longer single-file scripts, but projects with directory structures and module boundaries;
• Error self-repair: when runtime errors are fed back, the model can locate the problem and apply targeted fixes rather than starting over.

Two more community cases reinforce this point. One developer spent only about 5 minutes and $1.10 to have the model produce a launch short film based on browser-side 3D rendering—using the new model to promote the new model, which is itself rather telling. The more striking takeaway is that plain text instructions can now be turned into a finished video with 3D visuals and motion effects. Another developer ran a set of tests in which cloth fluttered in the wind and a robotic hand was disassembled into 2,317 parts; reportedly, two of those cases were completed within 10 minutes. Stability in organizing large numbers of objects and simulating physics is a direct manifestation of long-horizon task execution.

Token Economics: Doing the Cost Math

The Basic Logic of Tokens and Billing

A token is the unit models use to measure text and code. The total cost of a task can be approximated as:

Total cost ≈ (input tokens × input price + output tokens × output price) × effective iteration rounds

Note the “effective iteration rounds” term: if the model gets things right in one pass with little rework, actual costs stay low; otherwise, a large number of tokens is burned on repeated trial and error. This also explains why the cost of “similar work” can differ by an order of magnitude across models.

Cost Magnitudes from Community Cases

Case	Format	Time	Cost
Open-world game prototype	Interactive 3D scene	~10 hours	$51.98
Launch short film	Web-based 3D animation	~5 minutes	$1.10
Foldable phone interactive page	Modeling + web interaction	~1.5 hours	$12.50
Robotic hand disassembly demo	Physics simulation animation	Under 10 minutes	Not disclosed

Practical Cost Control Tips

• Keep context lean: retain only the code and notes relevant to the current subtask; irrelevant history wastes input tokens;
• Deliver in modules: generate and accept work module by module, so failures only require local rework;
• Define acceptance criteria: spell out the “definition of done” in your prompt to reduce rework caused by misunderstanding;
• Start small, then scale: validate gameplay or structure quickly at low cost first, then add detail incrementally.

A Reality Check: Demo Capability Is Not Production Capability

While celebrating the progress, keep the boundaries in view:

• Performance engineering is still human work: demos can tolerate dropped frames; production must handle low-end devices, slow-network loading, and memory leaks—optimizations that still need engineers in the lead;
• Architecture decisions cannot be outsourced: models excel at local implementation; system boundary design, technology selection, and long-term maintainability still require human judgment;
• Testing and review remain mandatory: AI-generated code still has to pass code review, unit testing, and security scanning;
• Data compliance comes first: in enterprise scenarios involving business code and sensitive data, work should be carried out through compliant LLM services or dedicated compute environments.

How to Replicate These Practices on the Cloud

For developers who want to try this in their own work, a practical path looks like this:

1. Pick an LLM service that matches your needs: cloud platforms—Baidu AI Cloud being one example—typically offer general-purpose capabilities such as LLM access and application orchestration;
2. Codify best practices into prompt templates: write task goals, technical constraints, and acceptance criteria into structured templates to cut per-task communication overhead;
3. Fill in the pipeline with standard cloud services: host static pages and 3D assets on object storage served through a CDN, deploy backend logic on a container platform, and add logging plus monitoring and alerting for observability;
4. Build a cost dashboard: log token consumption and spend for each task, and keep refining your prompts and iteration strategy.

Closing Thoughts

What this round of community showcases demonstrates is less “a certain model got stronger” and more that an LLM-and-human collaborative development paradigm is taking shape: the distance from idea to prototype has been compressed to hours, cost has been compressed to the tens of dollars, and the human engineer’s role has shifted upward toward architecture design, quality assurance, and experience polish. For developers, the most worthwhile move right now is not spectating—it is picking a small idea and turning it, with your own hands, into something that runs and can be played with. That will tell you more about the real level of this technology shift than any benchmark score.