LLMs Directly Writing 3D Modeling Scripts: Will It Reshape the Creator Ecosystem?

I. Why This Capability Leap Deserves Industry Attention

Over the past two years, updates from top AI labs have consistently sent shockwaves through the industry. However, updates from the open-source community are particularly noteworthy because every leap in open-source weights directly raises the ceiling of capabilities that enterprises can actually own and deploy.

Technically, this round of enhancement primarily stems from post-training: building upon existing base models, deep reinforcement of agentic capabilities is achieved through reinforcement learning, preference optimization, and large-scale targeted synthetic tasks. This explains a phenomenon: for the same generation of base models, the progress of new versions in the “doing” dimension can far exceed what parameter scaling alone can explain.

A more fundamental shift lies in the migration of evaluation standards: model competition has shifted from “who answers accurately” to “who can deliver engineering artifacts.” A model can only be considered a productivity tool if it can complete multi-step tasks in a terminal, directly produce usable code changes, generate 3D assets, and output analysis reports. Understanding this is key to understanding why terminal coding, direct 3D script writing, financial document reasoning, and security testing have become the four main battlegrounds of current model competition.

II. Code: From “Generating Snippets” to “Operating Terminals”

Terminal-based benchmarks no longer test static code completion; they evaluate a complete agentic loop: the model understands the task in a real command-line environment → breaks down steps → installs dependencies → executes → reads errors → fixes → re-verifies. A single failure at any step can cause the entire process to fail, demanding extremely high levels of planning, self-correction, and long-context management from the model. Furthermore, because such tasks inherently have high variance, rigorous evaluation requires multiple samplings to calculate the success rate statistically, alongside unified environment cleaning to avoid “accidental successes.”

Looking at recent public evaluation trends, two signals stand out:

1. Score Convergence: Top open-source models have broken through the 60% completion rate mark on these benchmarks, narrowing the gap with the strongest closed-source flagships to single digits, with some individual tasks even achieving overperformance—something unimaginable a year ago.
2. Cost is the Other Half of the Story: Lightweight models can minimize unit task costs but show a noticeable gap in completion rates compared to flagships. Conversely, top open-source models demonstrate a dual improvement of “scores approaching flagships at significantly lower costs.” This determines their actual viability in high-concurrency continuous integration, batch code migration, and automated ops scenarios. Evaluating a model cannot rely solely on scores; one must look at the “unit task cost” and “cost per point of improvement.”

Engineering Implications: When a model can stably operate a terminal, the deliverable of code generation shifts from “a snippet of code” to “a tested change.” The team’s focus should shift forward from “generation quality” to “validation and review mechanisms”—enforcing mandatory testing and human review for model-generated changes, upgrading “it runs” to “ready to merge.”

III. 3D Modeling: Why “Direct Script Writing” Might Break the Mold

On CAD benchmarks that rely on professional tools, top open-source models can now achieve scores around 92, only 3 to 4 points behind closed-source flagships (around 96)—the best level the open-source camp has reached to date. However, analyzing the implementation path is more critical than the scores themselves.

3.1 Comparison of Two Technical Paths

• Tool Invocation Path: The model calls atomic operations of modeling tools (create, move, boolean operation, change material) round by round through external protocols or middleware. This long chain involves many interaction rounds, with potential failure at every step, leading to high engineering complexity.
• Direct Script Writing Path: The model directly writes high-level scripting interfaces exposed by professional modeling and CAD tools, expressing “what to build, how to place it, and what material to use” as executable code in one go. This covers the entire workflow: asset setup, detailing, layout, material, and geometry adjustments.

The engineering value of direct script writing includes at least three aspects:

1. Versionable: Scripts are source code. They can be version-controlled, diffed, and reviewed. 3D assets now have a traceable “engineering history” for the first time.
2. Parametric: A script is an adjustable template. Changing radius, height, or material requires only altering a few variables, without rebuilding from scratch.
3. Low Dependency: No need to maintain an external tool invocation chain for every generation. The environment is simple, with fewer failure points, making it naturally suitable for embedding into automated pipelines.

3.2 Typical Structure of Generated Scripts (Pseudocode)

# —— Pseudocode: Illustrating the typical structure of "direct script writing", not a real API of any specific tool ——
# 1. Centralized parameter definition: subsequent manual fine-tuning only needs to change values here
PARAMS = {
    "lamp_radius": 80,        # Lampshade radius
    "lamp_height": 220,       # Lamp body height
    "segments":    64,        # Surface subdivision accuracy
    "material":    "Matte Plastic",
}
# 2. Geometry construction: describing shapes using semantic operations
def build_lamp(p):
    base  = cylinder(r=p["lamp_radius"] * 0.9, h=6)          # Base
    pole  = cylinder(r=6, h=p["lamp_height"] * 0.7)          # Lamp pole
    shade = revolve(profile=LAMP_PROFILE, n=p["segments"])  # Lampshade: curve revolve
    move(shade, y=p["lamp_height"])
    return assemble(base, pole, shade)
# 3. Material assignment and export
model = build_lamp(PARAMS)
set_material(model, PARAMS["material"])
export(model, "lamp.stl")   # Directly export 3D printable file

Observing recent public demos, direct script writing already covers three high-value scenarios. First, interior landscaping: placing a large number of organic vegetation in a large space is extremely time-consuming for manual modeling, while script-based generation with parameter fine-tuning can compress labor by an order of magnitude. Second, precision mechanical parts: geometric accuracy and assembly relationships can be precisely controlled via code, ideal for objects sensitive to curves like engines. Third, 3D-printable everyday items: from generation to exporting print files in one smooth flow, compressing the “idea to physical object” link down to minutes.

Complementary product forms have also emerged: online preview and parametric editing, exporting print files, or casually sharing videos and dynamic images—creation, validation, and distribution are forming a closed loop.

3.3 Why the “Open Source + Direct Scripting” Combo Can Truly Break the Mold

The real variable in the creative ecosystem is not the score of a single model, but the combination of “open-source weights + direct script writing.” Small and medium creative teams can deploy privately, fine-tune according to their own style, and batch-generate assets without paying per-call fees to external APIs. When capabilities can be “owned” rather than merely “rented,” the reconstruction of creative workflows will truly begin. This is the core criterion for judging whether it breaks the mold.

IV. Finance: From “Reading Tables” to “Verifying Figures”

Evaluations in financial scenarios are diverging into two categories:

• Document-level Complex Reasoning: Based on real financial documents (earnings reports, announcements, research reports), comprehensively testing retrieval, cross-document verification, and multi-step numerical reasoning. A typical challenge is inconsistent criteria—the same metric might differ across the main text, footnotes, and tables, and the model must determine which to rely on. Trend-wise, top models can now push scores above 60.
• Workflow-level Support: Covering the complete investment process from target screening to profitability analysis, where the gap between top open-source models and the strongest closed-source models has similarly narrowed to single digits.

More important than the score is hallucination control. Public evaluation trends show that the error rate of top models under rigorous hallucination stress tests has dropped from over 20% previously to under 10%. However, the red line in financial scenarios is “auditability.” Engineering should still implement four lines of defense: citation tracing (indicating the document source for every number), executing critical calculations via code (rather than letting the model do mental math), cross-validation with a dual-model setup, and leaving the “final number confirmation” to humans.

V. Security: The Other Side of Enhanced Capabilities

The expansion of post-training scale has also elevated model performance in vulnerability discovery, code auditing, and red/blue team exercises. For defenders, this means security teams can integrate models into code audit pipelines to batch-scan vulnerabilities and supply chain risks, shifting from “post-incident firefighting” to “pre-incident checkups.”

However, this same capability is a double-edged sword. When enterprises introduce high-capability models, they should simultaneously establish three gates: output-side abuse filtering, strict least-privilege access for sensitive scenarios, and pre-launch red teaming and gray release mechanisms. The stronger the capability, the earlier governance must be applied—this is the most easily overlooked yet critical aspect of this capability leap.

VI. Selection and Implementation: An Executable Framework

1. Build Your Own Evaluation Set: Public benchmarks are “health checkups,” not “job placement tests.” Sample 100 to 200 tasks from real business operations, covering target scenarios like coding, modeling, and document analysis, to form a repeatable regression test set.
2. Draw the Cost-Performance Curve: Plot unit task cost on the X-axis and task completion rate on the Y-axis. Rank candidate models based on “cost per point of improvement,” not leaderboard rankings.
3. Determine Deployment Form: For data-sensitive scenarios (finance, security, core assets), prioritize open-source weights with private deployment. For elastic needs and rapid validation, cloud inference services can be used. Taking Baidu AI Cloud as an example, container platforms and elastic GPU computing can host open-source model inference, object storage can uniformly manage 3D assets and evaluation data, and logging services with monitoring alerts can incorporate inference latency, failure rates, and hallucination rates into an observability system, making “model quality” a measurable operational metric.
4. Design Human-AI Collaboration Boundaries: Code—models generate changes, humans review before merging; 3D—models generate scripts, humans adjust parameters; Finance—models generate analysis, humans verify numbers. Every pipeline leaves the “last step” to humans.
5. Proactively Evaluate Asset Compliance: Copyright ownership of generative 3D assets, training data licensing, and financial data compliance should all be evaluated before introducing the capability, avoiding the “build first, patch later” approach.

VII. Conclusion: What “Direct Writing” Means

The essence of “direct writing” is that the model treats the scripting interfaces of professional tools as its native language for the first time: the same text serves as both a command for machine execution and a design document for human reading. As the boundary between code and design begins to dissolve, the focus of evaluation shifts from “can the model do it” to “can the team handle it.”

Advice for three types of readers: Developers should quickly integrate terminal and modeling tasks into their own evaluation systems; creative teams can run small-scale pilots in asset prototyping and parametric templates; enterprise decision-makers must realize that every leap in open-source weights raises the ceiling of privatized capabilities—an event more worthy of attention than any single leaderboard score.