Targeted control of fast prototyping through domain-specific interface
Authors: Yu-Zhe Shi
Mingchen Liu
Hanlu Ma
Qiao Xu
Huamin Qu
Kun He
Lecheng Ruan
Qining Wang
Venue: ICML 2025 poster (2025)
Keywords: Fast Prototyping
Domain-Specific Representation
Human Language Specification
Smart Manufacturing
Primary area: applications->everything_else

Abstract: Industrial designers have long sought a natural and intuitive way to achieve the targeted control of prototype models---using simple natural language instructions to configure and adjust the models seamlessly according to their intentions, without relying on complex modeling commands. While Large Language Models have shown promise in this area, their potential for controlling prototype models through language remains partially underutilized. This limitation stems from gaps between designers' languages and modeling languages, including mismatch in abstraction levels, fluctuation in semantic precision, and divergence in lexical scopes. To bridge these gaps, we propose an interface architecture that serves as a medium between the two languages. Grounded in design principles derived from a systematic investigation of fast prototyping practices, we devise the interface's operational mechanism and develop an algorithm for its automated domain specification. Both machine-based evaluations and human studies on fast prototyping across various product design domains demonstrate the interface's potential to function as an auxiliary module for Large Language Models, enabling precise and effective targeted control of prototype models.

Targeted control of fast prototyping through domain-specific interface
Yu-Zhe Shi 12
Mingehen Liu
Hanlu Ma"
Qiao Xu' Qining Wang'
Huamin Qu 24 Kun He
Lecheng Ruan"
Abstract
Using designer's language
Using modeling language
Cvak a righty Aend shape sstty hrmtipplur Raite deme heghh abrut
mont dightly tood teollettiio
Industrial designers have long sought a natural and intuitive way to achieve the targeted con- trol of prototype models-using simple natu- ral language instructions to configure and ad- just the models seamlessly according to their in- tentions, without relying on complex modeling commands. While Large Language Models have shown promise in this area, their potential for controlling prototype models through language remains partially underutilized. This limitation stems from gaps between designers' languages and modeling languages, including mismatch in abstraction levels, fluctuation in semantic preci- sion, and divergence in lexical scopes. To bridge these gaps, we propose an interface architec- ture that serves as a medium between the two languages. Grounded in design principles de- rived from a systematic investigation of fast pro- totyping practices, we devise the interface's op- erational mechanism and develop an algorithm for its automated domain specification. Both machine- evaluations and human studies on fast prototyping across various product design domains demonstrate the interface's potential to function as an auxiliary module for Large Lan- guage Models, enabling precise and effective tar- geted control of prototype models.
hndy'viddt coster ansh slgs il peofislyon with theiid
Bust by cretting lote diape aarnngng realing modiher alerr the vertical extr faom in nighttty
The should foot eroeeh flattond shape.
body
The great carner pritty un S-shape, whith starts and end nurrswrr tnterylow
Spout
Ratrade sylledried slon the Saapp putk, riporing the dinimirttor araadd ti. bur Ruslion dors seeich the Mirioonnccien. srin breat suistiisiinn mokk
Figure 1. Designers' language vs. modeling language for fast prototyping, This comparison clearly demonstrates that the de- signers' language for teapot design is significantly more intuitive than its modeling counterpart, providing a focused creation flow.
1. Introduction
Creating physical prototypes of the target products in a rapid iteration fashion, known as fast prototyping (Burns, 1993; Hallgrimsson, 2012), is one of the most critical pro- cesses professional industrial design (Camburn et al., 2017). helps maintain project timelines, alleviates de- sign fixation, and enables product testing against clear cri- teria. Unlike production-ready modeling conducted by gineers (Barnhill, 1992), which focuses on refining proto- types into master models for mass-production, fast proto- typing emphasizes exploring possibilities, extremes, and feasibility, providing essential references for final design choices. During this process, industrial designers actively and frequently make configurations and adjustments pro- totype models, driven by their unpredictable intuitions, insights, and inspirations. Limited by cognitive band- width (Lieder & Griffiths, 2020; Griffiths, 2020), industrial designers expect immediate feedback on how their inter- ventions affect the prototype's appearance without the need to switch attention to refining the current version of de- sign (Monsell, 2003), such as manually tuning the parame- ters of the Computer-Aided Design (CAD) model through the interactive Graphical User Interface (GUT) of model- ing engines. Such interruptions may disturb their contin- uous flow of thinking and creation (Cross, 2023). Conse- quently, industrial designers have been on the quest of an interface for the targeted control of prototype models one
'qqual contribution 'Department of Advanced Manufacturing and Robotics. College of Engineering, Peking University, Beijing. China Depprrment of Computer Science and Engineering, The Hong Kong University of Science and Technology, Hong Kong SAR 'School of Computer Science and Technology, Huazhong University of Science and Technology, Wuhan, China 'Division of Emerging Interdisciplinary Areas, The Hong Kong University of Science and Technology, Hong Kong SAR. Correspondence Lecheng Ruan cruanlecheng @uula.eduz, Qining Wang <qining- wang @ eeec@@ppu...cc pku.edu.cn>.
Proceedings of the 1nnd International Conference Machine Learning, Vancouver, Canada. PMLR 267, 2025. Copyright 2025 by the author(s).

---

Targeted control of fast prototyping through doeain-specific interface
that seamlessly implements their intentions as though the modeling controller were an extension of their clay-playing hands, mirroring their thoughts, as shown in Fig. 1. By pro- viding simple Natural Language (NL)-based instructions, the interface should ensure the appropriate realization of their intentions, avoiding under-specification, where inter- ventions are inadequately detailed, and over-specification, where unnecessary details distort the desired outcome.
2012). Following design convention, we use category to denote products sharing similar functionality, while adopt- ing the term domaii--peccffcctty from knowledge represen- tation theory to describe this category- -specffcc variation in semantics (Barsalou, 2008)-a convention we maintain throughout this paper. In essence, designers' languages re- flect human commonsense knowledge and intuitive think- ing patterns. They approach product design through a top- down methodology, breaking down products into semantic components and their interrelationships, while considering their physical properties. This approach aligns with design- ers' natural cognitive processes and practical needs,
Recent advancements in Artificial Intelligence (AI) have positioned Large Language Models (LLMs) as a promis- ing medium for interactions between industrial designers and modeling engines. These models can flexibly interpret designers' intentions through NL-based instructions, com- prehend and reason over the instructions, and generate cor- responding modeling commands. Researchers have begun exploring LLM-based tools to support CAD model creation and editing (Wu et al., 2023; Yuan et al., 2024). However, the potential of LLMs for fast prototyping with its targeted control demands has yet to be fully elicited, particularly fast prototyp-
In contrast to designers' languages, programming lan- guages of modeling engines are low-level, precise, and domain-agnostic.. First, the atomic constructs of mod- eling commands-bolk their concepts and associated operations-contall no abstract meanings beyond basic graphical semantics (Wilkinson, 2012). These commands operate solely on fundamental geometric elements such as points, curves, surfaces, shapes, intersections, and an- gles. This focus on basic geometric primitives ensures the commands maintain sufficient expressiveness for model construction. Second, modeling commands employ pre- cise quantization and parameterization, diverging from the ambiguous descriptive adjectives common in natural lan- guage, such as "big" or "sharp". They also avoid relative comparatives like "larger" or "sharper" that humans typi- cally use when assigning or adjusting properties (Kennedy, 2007). Third, the absence of abstract semantics in mod- eling commands renders them domain-agnostic rather than domain-specifte in industrial design applications (Mernik et al., 2005). While some encapsulated functions may pro- vide abstract operations, such as batch processing simi- lar parts, these functions remain bound by atomic oper- ations and reflect the modeling engine's rendering mech- anisms rather than addressing domain-speeitf design re- quirements (Shi et al., 2023b). In essence, modeling languages follow the logic of graphics description lan- guages and avoid maintaining prefabricated components for specific requirements. Instead, they require employing a bottom-up approach and building meaningful semantic functions through the composition of atomic elements.
in the context of the aurgttddnes--demanee ing (Uusitalo et al., 2024). In the practice of fast prototyp- ing via these tools, the designers' intuitive, subjective, and convention-driven instructions for property assignment and adjustment often not comprehended preciscly, thus the prototype models may not be targetedly controlled. These drawbacks stem from the substantial gaps between the de- signers' languages for describing their intention, and the underlying programming languages that drives the model- ing process through modeling commands.
Designers' languages exhibit three key characteristics: they are high-level, ambiguous, and domain-specific. First, these languages employ semantic references to describe both component parts and their relationships. For exam- ple, in teapot design, designers refer to specific parts like "pot lid" and "spout", as well as relationships such as the "relative position of pot lid and spout." This semantic ap- proach ensures the language remains intuitive for design- ers' practical use (Hannah, 2002). Second, these languages inherently contain ambiguity (Russell, 1923). Consider how the term "length" carries different meanings when ap- plied to different parts-the the "length" of a "pot lid" refers to distinetly different physical property than the "length" of a "spout" (Pei et al., 2011). This ambiguity extends to subjective operational instructions, such as "make the shape of the spout sharper", where the intended degree of modification remains uncertain. Third, these languages demonstrate strong domain-speciffeity. Each product cat- egory employs its own semantic vocabulary. Teapot de- sign uses terms like "pot lid", "spout", and relationships like "aatiiclaated" and "fused". In contrast, wardrobe de- sign employs different terminology such as "base plate", "column", "inner", and "beneath". This semantic tailor- ing extends across all product categories (Micheli et al.,
To bridge the gaps between designers' languages and modeling languages, we propose an interface built upon LLMs that translates designers' high-level, ambiguous, and domain-specific intentions into low-level, precise, and domain-agnostic modeling commands. Our design prin- ciples emerge from a systematic study of fast prototyp- ing practices and their cognitive foundations. The first principle establishes the interface as an intermediate-level
'The readers may refer to a commonly used, open-source CAD modeling language, FreeCAD, Visit the wehsite at https: / /wwwwww.... freecad. /rrg/
2

---

Targeted control of fast prototyping through domain-specifie interface
A
B
Granularity
Precision
Scope
Spout the lespot
Thickyn the spout
Refor part
Uncapsulated
Rational
"Handla"
Flatten
Iraaiional
"Hilt"
Figure 2. Illustrations of the gaps against the targeted control. (A) Designers' language contains semantically rich, encapsulated concepts. Improper handling of abstraction levels can lead to undesired semantic flattening. (B) Designers' language relies heavily on subjective references that require commonsense knowledge for proper interpretation. Improper specification of instructions may result physically or functionally inappropriate operations. (C) Designers' language is inherently domain-specific, where similar physical properties may be referenced by different semantic identifiers across product design domains.
Domain-Specific Language (DSL) between the two lan- guages (Fowler, 2010). This DSL uses designers' concepts and relationships as semantic identifiers, with each lan- guage construct encapsulating the atomic modeling com- mands needed to render parts or execute operations based on context. The abstraction level of this DSL must care- fully balance between the finest granularity of designers' languages and the broadest semantics of modeling lan- guages (Abelson & Sussman, 1996). The second princi- ple addresses targeted prototype control through precise in- terpretation of designers' intentions. The interface DSL must bind concepts (including parts and relationships) to their permissible operations. For instance, the "length" of "spout" permits operations like "increase" or "de- crease," but not "twist" or ing between a concept and its allowable second-order ad- justments. Similarly, the "relative position of pot lid and spout" can be specified through directional descriptions, creating a binding between a relationship and its permis- sible first-order assignments (Büring, 2005). These bind- ings ensure the interface remains both expressive and in- tuitive (Shi et al., 2024d). The third principle acknowl- edges the domain-specifie nature of the interface. While the DSL offers benefits of hierarchical encapsulation and pre- cise knowledge representation, each DSL. instance serves only one product design domain, as concepts and opera- tions vary significantly across domains. Manual creation of domain-speciff DSLS requires substantial effort and be- comes impractical for design agencies given the diversity of consumer products (Shi al., 2024a). Therefore, to en- sure practical utility, propose an automated mechanism for domain-specific interface specification.
main specification (Sec. 3); (iii) we evaluate the interface through both machine-based assessments and human stud- ies (Sec. 4), demonstrating its potential to bridge communi- cation gaps between diverse-minded experts while serving as an auxiliary module for LLM-based interaction tools.
2. The gaps against the targeted control
In this section, we systematically study the practices of fast prototyping in industrial design and analyze the three gaps between the designers' and modeling languages, within the three dimensions: level of abstraction (Sec. 2.1), semantic precision (Sec. 2.2), and domain domain-specifionn specificity (See. 2.3). Ac- cording to these investigations, we propose the correspond- ing design principles of the interface (Sec. 2.4).
bind-
2.1. Level of abstraction and granularity
This gap pertains to the level of abstraction and granularity of the language. In semantic theory, this aspect critically influences the conceptual density and operational granu- larity of language (Levinson, 2003). Designers employ high-level, semantically rich language that encapsulates complex concepts and relationships inherent to specific de- sign contexts. This language is closer to human natural language, which inherently high-level and contextually enriched. On the other hand, modeling commands uti- lize low-level, syntactically oriented language primar- ily focused on the precise execution of graphical opera- tions. These commands operate at a lower level of ab- straction, dealing directly with the geometrical and mathe- matical representations required to render objects, without the semantic enrichment seen in designers' language. As shown at Fig. 2A, the designer's semantic "spout of teapot" essentially encapsulates the modeling descriptions "a hol- low cylinder thick at the proximal and thin at the distal".
This study identifies the gaps between designers' and mod- eling languages in fast prototyping and proposes an in- terface to bridge these gaps. Our work makes three pri- mary contributions: (i) we conduct a systematic analysis of the gaps between designers' languages and modeling languages in practice (Sec. 2), deriving the design prin- ciples for the interface grounded in cognitive theory; (ii) we develop the interface architecture, detail its operational mechanisms, and design an algorithm for automated do-
2.2. Semantic precision and determinacy
This gap refers to the semantic precision and determinacy of the language. In the realm of semantics, this aspect is critical as it affects the interpretability and operational
3

---

Targeted control of fast prototyping through domain-specifie interface
specificity of the language (Lyons, 1995). Designers' lan- guage exhibits a higher degree of semantic indeterminacy, allowing for contextual and subjective interpretation and flexibility. This ambiguity is typical in natural language, where meanings can shift based on context, usage, and individual perception. In contrast, modeling commands demonstrate a semantic determinacy, with each command having a fixed and unequivocal meaning, devoid of con- textual interpretation. This precision is necessary for the accurate execution of graphical tasks, where ambiguity could lead to errors in design implementation. As shown at Fig. 2B, the designer's 's intention of "thicken the spout" implies a rational grounding of the diameter-related param- eters, which can be irrational if not properly specified.
tions. Crucially, the interface ensures that granular model- ing details remain transparent to designers, allowing them to focus on intent rather than implementation. For in- stance, an instruction to "soften the edges for an ergonomic feel" maps to parametric functions adjusting fillet radii without exposing the underlying modeling commands. To achieve this balance, the DSL employs function-like nat- ural language constructs that encapsulate atomic graphi- cal elements into reusable semantic identifiers (Bryant & O'Hallaron, 2011; Gulwani et al., 2017). This is achieved through a reciprocal development process: (i) top-down decomposition of designers' domain-specific terminology (e.g., breaking "part handle" into geometric primitives like "aagled cylinders with blended intersections") establishes semantic anchor for translation; while (ii) bottom-up en- capsulation aggregates atomic modeling commands (e.g., Boolean union, surface lofting) into higher-order func- tions (e.g.. "generate grip geometry") that mirror design- ers' mental models. By harmonizing these bidirectional strategies, the DSL operates at a "meso-scale" abstrac- tion-neither oversimplifying creative intent nor overcom- plicating execution thereby sustaining designers' cogni- tive flow while guaranteeing technical precision.
2.3. Lexical scope and semantic applicability
This gap highlights the lexical scope and semantic applica- bility of the language. From a semantic perspective, this involves the domain specificity or generality of the lan- guage (Saeed, 2015). Designers' language is characterized by domain--spciinn lexicons, tailored to particular design fields or product categories. This specialization enables designers to communicate effectively within their specific context, using terminology and concepts that are relevant to their particular field. Conversely, modeling commands are domain-agnostic designed to be universally applica- ble across various design fields without modification. This universality ensures that modeling engines remain versatile and broadly applicable, at the cost of not providing spe- cialized tools that cater to the nuances of specific design domains. As shown at Fig. 2C, referring to parts with sim- ilar physical properties within different product design do- mains require distinct semantic identifiers, such as "han- dle" in "fork" and "knit" in "cleaver knife".
Articulated concepts and operations This principle en- sures precise translation of designers' intentions through concept-operation bindings that reflect domain- de- sign logic. This is achieved by binding concepts (i.e., geometric parts or relational configurations) to spaces of permissible operations that reflect domain-specifit design logic. These bindings enforce semantic coherence by re- stricting operations to contextually valid transformations, thereby preventing mismatches between intent and execu- tion. Hence, the interface employs hierarchical syntax where operations are linked to governing concepts (Chom- sky, 1957; Shi et al., 2024c). The effective field of an op- eration is confined to the attributes of the associated con- cept. First-order operations (e.g., static descriptors like "smooth" or "short") directly modify attribute values, while sedond-order operations (e.g., dynamic comparatives like "smoother" or "shorter") adjust the incremental magni- tude of these modifications (Emde & Rollinger, 1983). Critically, the system maintains spatial-temporal continu- ity (Kuipers, 1986): attributes remain stable until explicitly modified, and operational effects stay consistent until re- calibrated. This structure balances expressive power with cognitive clarity (Felleisen, 1991), enabling precise intent articulation while avoiding excessive modeling choices.
2.4. Design principles for the interface
The three gaps highlight fundamental differences in de- sign conceptualization and communication. While design- ers' language is semantically rich, contextually flexible, and specialized, modeling commands are syntactically pre- cise, context-independent and generalized. To bridge these gaps, we propose three design principles derived from the tacit knowledge of industrial design practices.
Balanced hierarchy of abstraction This principle ad- dresses the alignment between designers' semantic lan- guage and modeling systems' rigid syntax through an intermediate-level DSL. This DSL is designed to pre- serve naturalness by maintaining the conceptual richness of designers' language (Myers et al., 2004; Hindle et al., 2016), such as terms like "organic form" " or "balanced pro- portions", while abstracting levelevel geometric operations like extrusion tolerances or fillet radii into executable func-
Automated domain specification This principle con- fronts the practical challenge of scaling the interface's 's util- ity across diverse product design domains, where manual crafting of DSLs becomes prohibitively costly due to the vast heterogeneity of concepts and operations (Pei et al.,
4

---

Targeted control of fast prototyping through domain-specifie interface
2011). The interface integrates a mechanism that au- tonomously derives domain-specifie linguistic and opera- tional landscapes by modeling the joint distribution of de- signers' language and modeling command patterns. Draw- ing from cognitive theories of concept acquisition (Kemp & Tenenbaum, 2008), where humans construct mental models by iteratively sampling and generalizing from ex- emplars (Tenenbaum et al.. 2011). the mechanism lever- ages LLMs repositories of commonsense knowledge to build generative models of design concepts (Yildirim & Paul, 2024). By framing LLM interactions as a stochastic sampling process, the system emulates human-like concept formation, where repeated exposure to diverse examples, mediated by the LLM's latent knowledge, gradually defines the boundaries and operational rules of domain-specifer concepts. This approach not only captures the breadth of real-world design variation but also ensures that the syn- thesized DSL remains grounded in both technical feasibil- ity and designers' linguistic norms. This approach trans- forms manual specification into a scalable, knowledge- driven workflow (Shi et al., 2024a; 2025), ensuring com- prehensive coverage while maintaining practicability.
interface Le into the problem, decomposing the original mapping into combination of mappings 9 : Ic Le and h Le + .M, where f = o g. The generative pro- cess can then be formulated as I. S C. _ M. The interface DSL L. = {Sc, where S. represents the set of DSL. constructs regarding the global shape, struc- ture, and layout of the set of parts of the target product, and Ag denotes the set of DSL constructs regarding the parts of the target product. An arbitrary permissible pro- gram generated by the DSL. can thereby be represented as L E S = {prog I prog E St U J.). Treating the in- terface as a latent variable in the likelihood maximization objective, we have
arg max pl (M) IT) M
= arg max L
Σ
((M L)p(L I1),
(2)
LEC:
where p(L I) and indicates p(M L) generative func- tions g and h respectively. Leveraging this latent variable formulation, we obtain relatively tractable estimation of p(M 1) with the interface as the medium.
3. The interface for the targeted control
3.2. Representation of the interface
In this section, we describe our proposed methodology for the target control of fast prototyping. We first present the problem formulation (See. 3.1). followed by the interface representation (Sec. 3.2), and we describe the algorithm for the domain adaptation of the interface (Sec. 3.3; Fig. 3).
Syntax of the DSL The local part construct is defined as A = (A, A, ox, Ux 2a),, where À denotes the seman- tic identifier of the referred part, as = (ax,i, ax.p) indi- cates the physical subpart ax,; (e.g., a handle or its con- stituent cylinder) and its associated physical property as (e.g., length, diameter), оλ represents the operation that is permissible to apply the physical property, Ux de- notes the quantitative value of the physical property (i.e., first-order value assignment), and va, indicates the quan- titative value of the extent of the operation (e.g., second- order value adjustment). The global construct is defined as S, = (s, as Os, Us, v2)), where 8 denotes the semantic identifier of the referred relationship between parts, a, in- dicates the joint descriptor of the physical subparts within the two parts (e.g., the relative position of spout and pot lid), o₂ represents the combinatorial operation over the re- lationship (e.g., make the relative position closer), o, rep- resents the combinatorial operation applied to the relation- ship. and vy combines the values of the two operations linked to the physical properties. The syntax of these lan- guage constructs mirrors the designer's intention, with each unit maintaining identical structural pattern.
3.1. The intention communication problem
Original formulation We consider the original problem of communicating the designers' intention with the mod- eling engine as mapping f Ie - M that trans- forms the space of intention Io to the space spanned by the possible command constructs of the modeling engine M. Each instance of intention I E I [4, [p} is trans- lated to a sequence of modeling commands M E M = (m),.... (MMM)).. where I represents the intention of con- figuration on the global shape, structure, and layout of the set of parts of the target product, and T, denotes the in- tention of configuration on the parts of the target product; my represents program indicating a modeling command. Hence, the objective of modeling according to the design- ers' intention can be maximizing the likelihood
arg max M
p(M] T)-
Hierarchical modeling According our semantic bind- ing design principle, we describe the DSL that generates language constructs using a top-down approach. In this hi- erarchy, lower-level elements are controlled by their imme- diate higher-Level elements: parts are generated based on the intention, physical subparts are generated from the part,
Integrating interface into the formulation Directly es- timating the likelihood p(M] | 7) can be intractable, given the substantial gaps between the designers' and modeling
languages. We introduce the intermediate-level DSL, the
5

---

Targeted control of fast prototyping through domain-specifie interface
Sampling unit language construct
Parallel Markov Chain Monte Carlo sampling C, (x)
Point-to-point
implementation
Local part
Global leyout
P
mondlie of loopeil..
Speat and hurndir of tespell..
Hierarchical decompasitionn
Aicmortor henaile....
Bibboettrllliierrm beheeen extrands.
A)
plts a.)
pla, ())
MMM C222)
elignnteem...
plax (n))
Hoo 12)
Incompatiblity pruning
Mocstrssanicaly slgnsdens.
plo (1
Non-parametric spectral clustering
Thickness
Figure 3. Representation and domain adaptation of the interface. This illustration conveys running example of adapting the inter- face to the teapot design domain. The iterative optimization alternates construct expansion (left) with feasibility validation (right).
operations are determined by physical properties, quanti- tative values are assigned according to their correspond- ing physical properties and operations. To maintain DSL expressivity that accommodates the high variability de- signers' intentions for the same target product (Shi et al., 2024b), we model the relationships between adjacent lev- els as conditional probabilistic generation (Wu al., 2019). This results in tree-structured hierarchical probabilistic model, which can be formulated as
with LLMs a Bayesian inference from the commonsense knowledge base IC with prior distribution p(K). serving as the prior of a latent generative model
(C, p(I, (K)((K)
(4)
where L. is iteratively refined through stochastic sampling. achieve this objective, wherein the interface DSL must accept the designers' language and generate the modeling language, derive the iterative algorithm with recip- rocative optimization framework (see Figs. 3 and 4).
fo),
=p(4 Ips a. o., Uos v', A, ax ux))) =p(i' I (odp(e o.)p(vx ax)p(ox ax)
(3)
Sampling from commonsense priors To initialize C.. we sample language constructs Ae and S. from the LLM- mediated prior p(KC), following their hierarchical architec- ture level-by-level. This is implemented as Markov Chain Monte Carlo (MCMC) process. The MCMC is initialized by drawing M seed sample constructs { (0) ...., -. } via
p(u, (s)p(o, a.)p(ax,a, s)p(( Ip):
representing the overall joint distribution of the designers' language and the interface.
I.M queries. For each seed sample r.(0), N Metropolis- Hastings steps are performed to explore the neighborhood of KC, specified as
3.3. Domain adaptation of the interface
The target of domain adaptation is to automate the design of the interface DSL L. given any domain design e (e.g., teapot, sofa, fence, racket, etc.). According to our de- sign principle of domain adaptation, we regard interacting
[(++) ~ qT.' (1) min (1, p(T' p((()K))
p(L1)) (2))
(5)
6

---

Targeted control of fast prototyping through domain-specifie interface
where the proposal distribution q is defined by LLM- generated perturbations. This process yields M x N sam- ples { ). ensuring diversity while preserving domain co- herence of the samples. The sampled constructs are clus- tered into semantically coherent units exploiting a non- parametrie Dirichlet Process Mixture Model (DPMM) to handle the unknown and variable number of domain con- cepts. Let 0g denote the parameters of the k-th cluster (e.g., one type of the handle within teapot), with a Chi- nese Restaurant Process prior (Blei et al.. 2010), each sam- ple is assigned to cluster k with probability proportional to its likelihood under p(Z,,) 0x) modeled as multi-
Inter-uperdemain
Inter-drmain
Campppte carse (4X danake)
1,00
C24
140
622
3.5
C228
0.29
120
0244
143
Spering
122
025
6:3
0.31
183
Kadaa
180
Figure 4. Running status of the domain adaptation algorithm. (A) Distinctions on language construct distributions cross super- categories and domains. (B) Convergence curves of the domain adaptation algorithm on eight domains.
nomial distribution over the elements (A, ax: ox....> and (s, as, .)....). The DPMM induces hierarchical tree structure, where nodes closer to the root represent macro concepts (e.g.. part), and nodes closer the leaves encode fine-grained variants (e.g.. physical properties).
human designers' iterative refinement prior knowledge recalled in context of current progress.
4. Experiments and results
Reciprocative optimization of granularity Though the sampling drawing and spectral clustering processes con- structs the initial structure of the interface, there is one side missing-the interface not only accepts the designers' lan- guage, but also outputs the modeling language. The actual granularity of the interface DSL is determined by the both sides. Therefore, we exploit an Expectation- Maximization (EM) Algorithm-like reciprocative optimization that alter- nates between construct expansion (i.e., Expectation) and feasibility validation (i.e.. Maximization). The Expecta- tion step expands the DPMM tree structure by sampling new constructs and proposing new clusters using the cur- rent interface c( as prior. The Maximization validates the constructs of the interface DSL via simulated synthe- size over the programming library of the modeling lan- guage. The validation phase categorizes each construct into three feasibility classes: (i) point-to-point implemen- tation, which can be implemented by atomic operations or predefined functions within the modeling language, then the construct should be maintained; (ii) hierarchical de- composition, which may be implemented by some encap- sulated functions within the modeling language, the con- finer granularity;
In this section, we report and discuss the results of our experiments for assessing the utility of the interface for targeted control. We start from describing our designer- participated fast prototyping tasks (Sec. 4.1), along with the metrics to measure the targetedness of the control of designers' intentions on the modeling engine (Sec. 4.2). Afterwards, we introduce the alternative methods equip- ping integrating different interfaces used for comparison (Sec. 4.3). Finally, we report and analyze the experimental results both quantitatively and qualitatively (Sec. 4.4).
Expecaaion-Maxiimzztion
4.1. Experimental setups
Experimental protocol We evaluate the targetedness of modeling control across two dimensions: rendering con- sistency and information clarity. We design a realis- tic fast prototyping scenario to simulate the targetedness- demanding design practices. Given the fundamental differ- ences between fast prototyping and production-ready mod- cling (Hallgrimsson, 2012), we limit the iteration count to ten rather than allowing unlimited iterations until the mod- eling becomes subjectively "satisfying". At the beginning, participants receive information about their target domain of product design. During each iteration, participants pro- vide one natural language instruction to the interface and receive images of rendered models generated by our inter- face and alternative methods. Participants then rank these images based on how closely they match their intended ef- fect. We collect these rankings for consistency measure- ment. Additionally, we gather the modeling programs gen- erated during this process for machine-based evaluation.
struct sample should be regenerated (ii)) incompatibility pruning, which cannot be implemented by the modeling language, such the physical property "material", the construct should be removed. After this Maximization-step the algorithm goes into the next iter- ation. The likelihood is maximized by iterating
((++)) = arg max E 2!") Pogke L), (6)
[logp(M
E())) indicates the mechanism to focus ex- ploration of IC based on the interface's 's current state. In- tuitively, this mechanism indicates that given the current interface state, what areas of the commonsense knowl- edge are most relevant to refine or expand it, mirroring
where p(A |
The human study includes 50 participants, each holding at minimum a Bachelor's 's degree in industrial design or related fields. All participants receive standard- ized task instructions and provide informed consent. For
Participants
7

---

Targeted control of fast prototyping through domain-specift interface
A
Consistency
Consistency (Touser))
Comiisency (Tespot)
Consissency (Pan)
Consistency
3.04
30-
2.04
20-
2.0
20-
1.0
1.0
100
1.0
1.0
Our-Int LLM-Int wio-Im
Our-Int LLM-Int wio-fa
Our-Int LLM-Imi wio-Int
Our-Ini LLM-fa wlo-In
Our-Int LLM-Int wio-In
Clarity
Comistency (Cleover
Consisency
Comsisenccy (Wheelsumon)
Consistency (Unicycle)
3.
1.0
30-
30-
3.0
0.5
2.0-
2.0
0.0
1.0
140
1.8
1.0
Our-Ter
M.M
wio-Ir
Qur-Tor L.M-lo wio-Ier
Our-Int ELM--m wio-Ta
Our-Int LLM-ltr
wis-Ini
Our-lat 1.M-Int wil--nr
D
Our-Int
LLM-Int
w/o-Int
Attack circular
handle opposite side of the spout.
Entarge the wheels by an appropriate
Figure 5. Quantitative and qualitative results. (A) Results on rendering consistency assessment across all domains. (B) Isolated domain- wise results on rendering consistency assessment. (C) Results on information clarity assessment across all domains. (D) Showcases collected from the fast prototyping tasks. The leftmost text is the designer's instruction. Each pair of visualizations indicates the models before (left the arrow) and after (right to the arrow) intervention.
ethical considerations, please refer to Appx. B.
between adjacent design versions, as each intervention rep- resents a state transition. Therefore, we apply uniform weighting to step-wise result rankings across each design task, with higher scores indicating better performance.
Materials ensure experimental generality, we select eight product design targets from major consumer market supercategories (Pei et al., 201 I): kitchen appliances (i.e., teapot, pan, fork, toaster, and cleaver knife), furniture (i.e.. sofa), gardening equipment (i.e., wheelbarrow), and sport- ing goods (i.e., unicycle). We choose products across these supercategories to examine inter-supercategory differences and selected multiple products within supercategories to study intra-supercategory domain-wiss variations. To thor- oughly test interface utility, intentionally select chal- lenging products with irregular geometric features, such teapots, sofas, wheelbarrows, and unicycles.
Information clarity assessment For each participant in- tervention step, we analyze the corresponding modeling programs for uncertainty by examining the modeling pro- gram library documentation (Chaitin, 1977). We analyze function Abstract Syntax Trees (ASTs) and calculate un- certainty based on the cumulative depth of specified pro- gram constructs along the resulting AST. Greater cumula- tive depth indicates lower uncertainty and higher informa- tion clarity. Higher scores represent better performance.
4.2. Evaluation metrics
4.3. Alternative methods
Rendering consistency assessment We measure the consistency between participant intentions and modeling results using the ranked order of results from each inter- vention step, following established methodology in similar human studies (Lake et al., 2015). We treat the iterative process as Markov Process, considering only transitions
Our comparison with alternative methods required to answer two key questions. First, is our interface archi- tecture necessary for the targeted control, specifically the transformation from standard likelihood maximization to our latent variable interface approach? Second, are our interface implementation principles, particularly the hier-
8

---

Targeted control of fast prototyping through domain-specifie interface
archical DSL-based representation, essential for the tar- geted control? To address the first question, we develop w/o-Int, an alternative model that processes design- ers' language directly without interfaces. For the sec- ond question, we created LIIMInn, an interface imple- mented through pure LLM-based prompt engineering, as a direct comparison to our proposed interface. We refer to our DSL-represented interface model as Our-Int. Each domain-specific instance of Our-Int is automatically de- signed through the algorithm described in Sec. 3.3, All methods are built upon state-of-the-art text-to-modeling program generators (Wu et al., 2023; Yuan et al., 2024).
complexity of generated modeling programs led to higher probabilities of run-time errors during modeling engine ecution. However, this limitation is relatively minor, as cur- rent LLM- based program fixers can iteratively refine pro- grams based on error messages (Madaan et al., 2023).
5. General discussion
In this study, we propose interface enhance targeted control of fast prototyping by bridging the gap between de- signers' languages and modeling languages. Experimen- tal results demonstrate our interface's effectiveness and suggest its potential as an auxiliary module for LLMs in broader human instruction specification tasks.
4.4. Results
Rendering consistency Paired samples t-tests reveal that Pur-Int significantly outperforms both alternative meth- ods across all eight domains in rendering consistency
On the cost of inter-domain communication Commu- nication costs present a significant challenge in collabora- tive efforts. Domain experts from different backgrounds come with diverse mindsets, thereby using distinct DSLs accordingly, which often remain misaligned without exten- sive trial-and-error collaboration (Shi et al., 2023a). This challenge is particularly evident in industrial design and manufacturing, where designers must interpret high-level Part-A indicators, requirements, and preferences; while modeling engineers and their tools must implement low- level designs within spatial, graphical, and physical con- straints. The substantial language differences between these groups traditionally result high communication costs. Our interface aims reduce these costs, potentially enabling more balanced and reciprocal relationship be- tween design creation and prototype implementation. The broader prospect of our methodology is to provide human experts with a natural language programming interface that enables direct high-level instructions, while low-level exe- cutions are encapsulated under semantic identifiers within the interface, remaining transparent to domain experts.
(Our-Int vs. LLM-Int, ((7183) = 80.60, p < .0001;
Our-Int vs. w/o-Int: t(7246) = 63.81.p < .0001:
see Fig. 5A)2. Domain-specific analyses also show sig- nificant superiority of our approach in isolated compar- isons (see Fig. 5B). Furthermore, LLM-Int demonstrates significant overall improvement compared to w/c- IIt (t(7127) = 12.37, p < .0001; see Fig. 5A), supporting the necessity of the interface structure. These findings validate our approach from a black-box outcome perspective.
Information clarity Paired samples t-tests demonstrate that Our-Int significantly outperforms both alternative methods across all eight domains in information clarity (Our-Int vs. LLM-Int: t(14) = 4,413,p < .001; Our-Int vs. w/o-Int: ((14) = 3.277, < .01; see Fig. 5C). These results validate our proposal from a white- box intermediate result perspective.
Discussion Comparison between Our-Int and alterna- tive methods reveals significant advantages in targeted con- trol: (i) while alternative methods only modify parame- ters at a coarse level, Bur-Int successfully handles fine- grained instructions such as "attach" and "opposite" (see Fig. 5D); (ii) Our-Int precisely interprets subjective ref- erences to values and operation extents, and also domain- specific references to parts and physical properties, while alternative models often reference incorrect objects for op- erations, apply inappropriate operation types, and generate physically implausible results (e.g., oversized wheels con- flicting with the framework in the wheel size adjustment case; see Fig, 5D). These qualitative observations further support our interface's 's utility. We notice that the increased
On the domain generalizability of the interface A key consideration whether interface representations should be specific or general across product design domains. While universal interface might seem appealing, creat- ing a truly general one-size-fits-all solution for all prod- uet design domains presents significant challenges. Al- though theoretically possible to develop a comprehensive designers' language covering all requirements, such a sys- tem would become overwhelmingly complex, with over- lapping semantics and intertwined references that design- ers would find impractical. Conversely, attempts to sim- plify this universal interface would inevitably compromise its representational capabilities, leading to the expressivity- complexity dilemma (Abelson & Sussman, 1996). There- fore, rather than pursuing elusive generality, a more prag- matic approach may be to focus on developing and au- tomating the adaptation of domain-specific interfaces.
"The varying degrees of freedom in different I- t-tests result from some participants only selecting results with highest consistency without completing the full ranking. Such incomplete data cases represent less than 2% all collected data.

---

Targeted control of fast prototyping through domain-specifie interface
Acknowledgements
Barnhill, R. E. Geomelry processing for design and manu-
facturing. SIAM, 1992.
This work is partially supported by the National Natural Science Foundation of China under Grants 52475001 and RGC GRF Grant 16210321. Q. Xu visiting student at Peking University from University of Science and Technol- ogy of China.
Barsalou, L. W. Grounded cognition. Annual Review of Psychology, 59(1):617-645, 2008
Blei, D. M., Griffiths, T. L.., and Jordan, M. I. The nested chinese restaurant process and bayesian nonparametric inference of topic hierarchies. Journal of the ACM (JACM), 1702), 2010.
Impact statement
This work explores bridging high-level industrial design instructions and low-level modeling implementations in cost-efficient manner for fast prototyping of industrial designs through the automatic design and deployment of domain-specific interfaces. Our proposed methodology ex- tends beyond industrial design to address a fundamental challenge in smart manufacturing: aligning requirements from design teams (Part-A) with production capabilities (Part-B). This alignment has long been costly bottleneck that limits manufacturing efficiency, particularly given the current trend toward small-batch, muulii-vriitty produc- tion. The challenge manifests in three critical gaps: level of abstraction, semantic precision, and domain comaai-specifficity which together hinder rapid product iteration.
Bryant, R. and O' O'Hallaron, D. R. Computer systems: a programmer's perspective. Prentice Hall, 2011.
Büring, D. Binding theory. Cambridge University Press, 2005.
Burns, M. Automated fabrication: improving productivity in manufacturing. Prentice-Hall, Inc., 1993.
Camburn, B., Viswanathan, V., Linsey, J., Anderson, D.,
Jensen, D., Crawford, R., Otto, K., and Wood, K. De- sign prototyping methods: state of the art in strategies, techniques, and guidelines. Design Science, 3:, 2017.
Chaitin, G. Algorithmic information theory. IBM Journal of Research and Development, 21(4):350-355 1977.
In response to these challenges, this work highlights the importance of managing tacit knowledge in manufactur- ing. The natural DSL used by specific Part-A or Part-B teams should be standardized toward sound and com- plete DSL within their respective domains to avoid insuf- ficient detail, ambiguity, and excessive jargon. Interfaces serve as cnermaation-peservviin translators that map stan- dardized Part-A DSL programs to executable Part-B DSL programs, enabling customized point-to-point communica- tion between any pair of Part-A and Part-B components.
Chomsky, N. Syntactic Structures. Mouton de Gruyter, 1957.
Cross, N. Design thinking: Understanding how designers think and work. Bloomsbury Publishing, 2023.
Emde, W. and Rollinger, C.-R. The discovery of the equa- tor or concept driven learning. In International Joint Conference on Artificial Intelligence, 1983.
From a system-level perspective of the entire manufactur- ing supply chain, all suppliers are interconnected through a communication busline. The interfaces provide suppli- ers with access to this busline while incorporating the uni- fied requirements of the Original Equipment Manufacturer (OEM) that governs the supply chain. These interfaces can be customized for each supplier at low cost because they designed through highly automated processes. This au- tomation is practical given the substantial volume of histor- ical communication data records between Part-A and Part- components, combined with L.LMs for manufacturing that serve as commonsense knowledge bases. This stan- dardization methodology has the potential to improve both the quality and efficiency of manufacturing supply chains.
Felleisen, M. On the expressive power of programming languages. Science of computer programming, 17(1-3): 35-75, 1991.
Fowler, M. Domain-specify languages. Pearson Educa- tion, 2010.
Griffiths, T. L. Understanding human intelligence through human limitations. Trends Cognitive Sciences, 24(1 1): 873-883, 2020.
Gulwani, S., Polozov, O., Singh, R., et al. Program syn- thesis. Foundations and Trends@ in Programming Lan- guages, 4(1-2):1-119, 2017.
Hallgrimsson, B. Prototyping and modelmaking for prod- uet design. Laurenceking, 2012.
References
Abelson, H. and Sussman, G. J. Structure and interpreta- fion of computer programs. The MIT Press, 1996.
Hannah, G. G. Elements of design: Rowena Reed Kostel- low and the structure of visual relationships. Princeton Architectural Press, 2002.
10

---

Targeted control of fast prototyping through domain-specifie interface
Hindle, A., Barr, E. T., Gabel, M., Su, Z., and Devanbu, P. On the naturalness of software. Communications of the ACM, 59(5):22--131, 2016.
Russell, B. Vagueness. The Australasian Journal of Psy- chology and Philosophy, 1(2):84-92 92, 1923.
Saeed, J. Semantics. John Wiley & Sons, 2015.
Kemp, and Tenenbaum, J. B. The discovery of structural form. Proceedings the National Academy of Sciences, 105(31):10687-10622 2008.
Shi, Y.-Z., Li, S., Niu, X., Xu, Q., Liu, Xu, Y., Gu, S., He, B., Li, X., Zhao, X., et al. PersLEARN: Research Training through the Lens of Perspective Cultivation. In Anmual Meeting of the Association for Computational Linguistics, 2023a.
Kennedy, C. Vagueness and grammar: The semantics of relative and absolute gradable adjectives. Linguistics and Philosophy, 30:1 2007.
Shi, Y.-Z., Xu, M., Hoperoft,
He, K., Tenenbaum, J. B., Zhu, S.-C., Wu, Y. Han, W., and Zhu, Y. On the complexity of Bayesian generalization. In International Conference on Machine Learning, 2023b.
Kuipers, B. Qualitative simulation. Artificial Intelligence, 29(3):289-3323 1986.
Lake, B. M., Salakhutdinov, R., and Tenenbaum, B. Human-level concept learning through probabilistic pro- gram induction. Science, 350(6266):1332-13333 2015.
Shi, Y.-Z., Hou, H., Bi, Z.., Meng, F., Wei, X., Ruan, I.., and Wang, Q. AutoDSL: Automated domain seeeiiii--pefiieee lan- guage design for structural representation of procedures with constraints. In Annual Meeting of the Association for Computational Linguistics, 2024a.
Levinson, S. C. Space in language and cognition: Ex- plorations in cognitive diversity. Cambridge University Press, 2003.
Shi, Y.-Z., Li, H., Ruan, L.,, and Qu, H. Constraint rep- resentation towards precise data-driven storytelling. In IEEE Visualization and Visual Analytics Gen4DS Work- shop, 2024b.
Lieder, F. and Griffiths, T. Resource-rational analysis: Understanding human cognition the optimal use of limited computational resources. Behavioral and Brain Sciences, 43:e1, 2020.
Shi, Y.-Z., Meng, F., Hou, H., Bi, Z., Xu, Q. Ruan, L., and Wang, Q. Expert-level protocol translation for self- driving labs. In Advances in Neural Information Pro- cessing Systems, 2024c.
Lyons, J. Linguistic semantics: An introduction. Cam- bridge University Press, 1995.
Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., Alon, U., Dziri, N., Prabhumoye. S., Yang. Y., et al. Self-refine: Iterative refinement with self- feedback. In Advances Neural Information Processing Systems, 2023.
Shi, Y.-z., Xu, Q. Meng, F., Ruan, L.,, and Wang, Q. Ab- stract Hardware Grounding towards the Automated De- sign of Automation Systems. In International Confer- ence Intelligent Robotics and Applications, 2024d.
Shi, Y.-Z., Liu, M., Meng, F., Xu, Q., Bi, Z., He, K., Ruan, I.,, and Wang, Q. Hierarchically Encapsulated Repre- sentation for Protocol Design in Self-Driving Labs. In International Conference on Learning Representations, 2025.
Mernik, M., Heering, J., and Sloane, A. M. When and how to develop domain-specific languages. ACM Computing Surveys (CSUR), 7(4):316-344 2005.
Micheli. P., Jaina, J., Goffin, K., Lemke, F., and Verganti, R. Perceptions of industrial design: The "means" and the "ends". Journal of Product Innovation Management, 2975):6877704, 2012.
Tenenbaum, J. B., Kemp, C., Griffiths, T. L., and Goodman, N. D. How to grow a mind: Statistics, structure, and abstraction. Science, 33 (316622)) 2011.
Monsell, S. Task switching. Trends in Cognitive Sciences, 7(3):134-140, 2003.
Uusitalo, S., Salovaara, A., Jokela, T., and Salmimaa. M. clay to play with": Generative ai tools in ux and indus- trial design practice. In Proceedings of the 2024 ACM Designing Interactive Systems Conference, 2024.
Myers, B. A., Pane, J. F., and Ko, A. J. Natural program- ming languages and environments. Communications of the ACM, 47--22 2004.
Wilkinson, L. The grammar of graphics. Springer, 2012.
Pei, E., Campbell, I., and Evans, M. A taxonomic classifi- cation of visual design representations used by industrial designers and engineering designers. The Design Jour- nal, 14(1):64 91, 2011.
Wu, S., Khasahmadi, A., Katz, M., Jayaraman, P. K., Pu, Y., Willis, K., and Liu, B. Cad-llm: Large language model for cad generation. In NeurIPS 2023 Workshop on Machine Learning for Creativity and Design, 2023.

---

Targeted control of fast prototyping through domain-specifi interface
Wu, Y. N., Gao, R., Han, T., and Zhu, S.-C. A tale of three probabilistic families: Discriminative, descriptive, and generative models. Quarterly of Applied Mathematics, 77(2):423-4655 2019.
Yildirim, I. and Paul, L. From task structures world mod- els: what do LLMs know? Trendy in Cognitive Sciences, 2024.
Yuan, 7.,, Shi, J., and Huang, Y. OpenECAD: An effi- cient visual language model for editable 3D-CAD de- sign. Computers & Graphics, 124: 124:104048, 2024.
Zheng, L., Chiang, W.-L.., Sheng, Y., Zhuang, S., Wu, Z., Zhuang, Y., Lin, Z., Li, Z., Li, D., Xing, E,, al. Judging alm-as-a-judge with mt-bench and chatbot arena. In Ad- vances in Neural Information Processing Systems, 2023.
12

---

Targeted control of fast prototyping through domain-specifie interface
A. Additional remarks
A.I. Rationale for the proposed methodology
Notably, this work is not an alternative to LLM-based CAD generators, but rather an interface to improve the performance of LLM-based CAD generators by bridging designers' language with modeling engineers' language. The fundamental challenge is that while modeling languages are hierarchically documented, designers' language is not standardized in the wild. This necessitates systematic representation of concepts described in designers' language-from product categories to structures, components, attributes, and operations. This requirement aligns with word learning in cognitive science, where humans learn systems of interrelated concepts rather than isolated terms.
Drawing inspiration from cognitive development, we mirror how people learn concept networks by sampling from the environment and organizing these samples into hierarchical structures through DPMM. This spectral clustering approach captures multi-level attributes rather than clustering based on overall similarity. In our approach, we substitute environ- mental sampling with ALM-ggnerated samples, as LLMs are recognized repositories of commonsense knowledge. We then apply DPMM to cluster these samples into a hierarchy of structures, components, attributes, and operations. This system- atic representation allows natural instructions from designers to be decomposed into fine-grained elements that align with modeling language constructs, enabling targeted control in fast- fast-prototyping.
A.2. Rationale for the selected evaluation metrics
Fast prototyping allowing designers to explore brainstormed ideas without elaborating their instructions into modeling engineers' language. Our approach is explicitly two-stage, with our proposed interface serving as the first stage and LLM- based CAD generators as the second. Our metrics were selected to measure specific aspects of the process. Specifically, we use rendering consistency to measure how well the interface captures designers' intentions, essentially evaluating desired elements appear and undesired ones are suppressed. Meanwhile, information clarity metrics quantify how effectively information transfers between designers' high-level language and modeling engineers' fine- line-grained requirements.
A.3. Rationale for the protocol of design study
Fast prototyping differs from full design. While full design requires master models for mass production, fast prototyping serves as an exploration for primary design ideas. Design studies often use two setups: (i) counting iterations to reach certain results; or (ii) evaluating improvements within a fixed iteration count. We adopt the latter to assess the improvements of each iteration with the same instruction, therefore relatively invariant to the number of iterations. The current choice of 10 is informed by discussions with professional industrial designers to capture the typical lifecycle of fast prototyping, and would be further investigated in further study.
Also, we would like to clarify that we aim to directly assess the targetedness of each individual design instructions, e,g., "make the spout narrower". This measure is somewhat subjective, as designers must evaluate whether desired changes were implemented while undesired changes were suppressed. Our work requires step-by-step assessment of each instruction within sequence leading to final product, whereas existing datasets typically evaluate only the final result after multiple instructions. This fundamental difference means that while conventional methods can create groundtruth references in advance, our approach relies on designers' on-the-fly instructions, making it impractical to prepare ground truth data (e.g.. point clouds) beforehand.
A.4. Rationale for not comparing with more baselines
We would like to first clarify that our work is not proposing an alternative to LLM-based CAD generators, but rather an interface to improve the performance of those generators. Our approach is explicitly two-stage, with our interface serving as the first stage and LLM-based CAD generators as the second. To our knowledge, there are no established state-of-the-a baselines for direct comparison of the entire two-stage pipeline. Comprehensive baselines exist for the second stage, so we have adopted the current -tate-of-the-art to evaluate the first stage, subject our proposed interface.
A.5. Relations with program synthesis
Our automated interface design shares conceptual similarities with program synthesis in achieving hierarchical abstrac- tion through iterative sampling and refinement. However, two key distinctions exist. The first lies in the perspective of
A1

---

Targeted control of fast prototyping through domain-specifie interface
knowledge representation. Program synthesis relies on structured knowledge, using exemplar DSL programs generate higher-level libraries. In contrast, approach samples from unstructured commonsense knowledge bases (e.g., LLMs)) and organizes knowledge into DSL. The second comes from the perspective of machine learning paradigm. Program synthesis follows a supervised approach, leveraging I/O pairs with task specifications, whereas our method is unsupervised, emerging from commonsense knowledge bases.
B. Ethics statement
The human studies included in this work has been approved by the Institutional Review Board (IRB) of Peking University. We have been committed to upholding the highest ethical standards in conducting this study and ensuring the protection of the rights and welfare of all participants. We paid the participants a wage of $22.5/h, which is significantly higher than the standard wage.
We have obtained informed consent from all participants, including clear and comprehensive information about the pur- pose of the study, the procedures involved, the risks and benefits, and the right to withdraw at any time without penalty. Participants were also assured of the confidentiality of their information. Any personal data collected (including name, age, and gender) was handled in accordance with applicable laws and regulations.
C. Experimenting details
C.1. Resulting models from fast prototyping
Teapot
Toaster
Pan
Fork
Cleaver knife
Sofa
Wheelbarrow
Unicycle
Our-Int
LLM-Int
w/o-Int
Figure Al. Visualization of the modeling results from the fast prototyping tasks
C.2. Showcases of designers' instructions
There is sample of ten-iteration instructions by one participant in the fast prototyping task of teapot design as follows.
1 1. Make the main body rounded sphere.
2 2. Flatten the sphere slightly.
3 3. Create a short cylindrical neck at the top.
4 4. Attach dcme-shaped lid to the neck.
5 5. Extend a spout from the side of the body.
6 6. Make the spout curved.
7 7. Make the spout narrower toward the tip.
8 8. Attach terus handle to the opposite side of the spout.
9 9. Align the spout, body, and handle along the same horizontel axis.
10. Keep the handle and the spout symmetrical.
There is sample of ten-iteration instructions by one participant in the fast prototyping task toaster design as follows.
A2

---

Targeted control of fast prototyping through domain-specife interface
Teapot
Mria harra body runded ophers
Paden sptore sighty
Crease Ehot cpindical
Arach donseetaped mack. Edardd spoucomm
spoe
Mikes soou rarover lovert
Vitte opporiiiiii
ant tovid sore The spec syemeticcll
da spou.
sarve botarid
Our-Int
LLM-int
Toaster
Form the redangdar.
Mako body
Poeidon Survatee
Armaga dita
Pless teo
willd andd...
Rodken vaaa frrtt comers
diilk
nighty
Our-int
wio-int
LLM-Int
Sofa
Stape man buns Exaanl the buctres,
Hound odge messgast beckral smootty.
Form the seal custers restengule
Leans sona space seel ousicia
Shape the umrenta
purpendouter the and the hurn.
Shape the four logs
Pabe bollon
Angli bn lig
frmn.
wio-Int
LLM-int
Figure A2. Step-by-step rendering results some samples from prototyping tasks
1 1. Form the rectangular body with rounded edges.
2 2. Make the body wider.
3 3. Position four vertical cal slots the top surface.
4 4. Arrange the slots in two pairs.
5 5. Make the slots short.
6 6. Place
front box levers.
7. Design each lever with flat handle.
8. Fosition two rotary dials the lower front corners.
9 9.
Recess the dials into the frent panel.
10.
Construct slightly elevated base.
A3

---

Targeted control of fast prototyping through domain-specifie interface
There is sample of ten-iteration instructions by one participant in the fast prototyping task of sofa design follows.
1 1. Shape the main frame into a rectangular form.
2 2. Extend the backrest upward with a slight curve.
3 3. Round the top edge of the backrest smoothly.
4 4. Form the seat cushions into two parallel rectangular shapes.
5 5. Leave scme space between the two seat cushions.
6 6. Shape the armrests into cylindrical forms.
7 7. Place the armrests perpendicular to the backrest and parallel to the main frame.
8 8. Shape the four legs into tapered cylindrical forms.
9 9. Raise the bottom of the sofa slightly.
10. Angle the legs slightly outward.
C.3. Showcases interface DSL programs
There is sample DSL program collected from the fast prototyping of teapot design as follows.
1
2
"Parts":
3
"body":
4
"sphcre_0"; ["radius"]
5
1,
"neck":
7
"cylinder_O"; ["height", "radius", "diameter"]
,,
9
"lid":
"sphere_0"; ["height"]
11
,
12
"knob":
13
"sphere_0"; ["height")
14
15
spoutt: {
16
cone_o"; ["height", "angle", "radius"),
17
"cylinder_1i 1"; I"diameter", "radius", "Length", "height")
18
"handle": {
"torus_0"; ("length", "height", "radius")
}
23
"Relationships".
24
"boay <-> neck": ("top center"),
25
"neck <>> lid": ["flush"],
26
"lid <>> knob": ["top center"],
27
"body <-> spout": ["side", "alioned_borizontall,, "tilteddupward",,
28
horizontal", "higher") "pody <-> handle": ["side", "opposite_ ", "
29
30
There is sample DSL program collected from the fast prototyping of toaster design follows.
1
2
"Parts":
3
"body":
A4

---

Targeted control of fast prototyping through domain-specifie interface
"rounded_box_O"" ["height", "length"]
,,
6
"slot_1"; {
7
"rectangle_0"; ("width", "Length", "height"]
8
9
21ot_2": {
10
"rectangle_0"; ("width", "length", "height"]
11
,,
12
slot__3:
13
"rectangle_0"; ["width", "length", "height"]
14
,,
15
"slot_4"
"rectangle_0": ["width", "length", "height"] , poot_er_slot_1! |
"thin_box_0": ("width", "length", "height") ,
21 "border_slct_2"" {
22
"thin box_ 0": ("width", "length", "height")
23
,
24 "border_slct_"" {
25
box 0"; I"width" "Length", "height")
26
,
27
"border_slct_4" {
28
btx ("width", "length", "height"]
29
,
30
"lever_
31
"curvo__flat_handde_01 ("height", "radius"]
,
"lever_2": 2":
Carvee__flt__handle__ ("height", "radius"]
35
,
36
mnnide_railly raiis_lever________________1_
37
vertical__hin_box_000 0": ["length", "height", "width"]
38
,
39
40
peprtical_thin.o box_ ["length", "height", "width"]
41
,
42
"dial_1";
43
"cylinder_0"" 0"; ["height", "radius"]
44 ,
45 "dial_2":
"cylinder_O": ["height", "radius"]
47 ,
48 "base":
49
elevateeeeee ["length", "width", "height"]
50
,
51
"crumb_tray":
52 "thin_box_00 0": ["length", "height", "width")
53
,
54
"storage_area":
A5

---

Targeted control of fast prototyping through domain-specific interface
"cuboid_0" ("height", "radius"]
,,
57
"power_cord;;
58
"cylinder_O": ("height", "radius"]
59
60
}
61
"Relationships"
62
"pody <-> slot 1": I"top", "aliined" ,
63
"body <>> slct_2": ["top", "aligned"],
64
"body <-> slct_3"; ["top", "aligned"],
65
"pody <-> sict_4"; ("top", "aligned"),
66
"slot_1 <-> gorder_slot... ("surround"),
"slot_2 <-> border_slot__": ("surround"),
"slot_3 <-> border_slot_3": ("surround"),
"slot_4 <-> border_slot_ ["surreund"),
"lever_l <-> guide_rails_lever_11 ("beside"),
71
"lever_2 <-> guide_raiil__ever__2" ["beside"),
72
"lever_1 <-> slot_1": [*aligned"),
73
"lever_2 2 <-> slot_3": |*aligned"),
74
"body <>> dial_1": ["front_batteerccrmme"" "recessed"),
75
"body <-> dial_2"; ["front_bottor_cormee") recessed"),
76
"dial_1 <->
_iainttt__ddi___:_________" ["around"],
77
"dial_2 <>> : ( ("around"),
78
"body <-> base": ("beneath", "contrast"),
79
"base <-> crumb_tray": ("top", "slide_outward""
80
area": ["rear"], "storage_area power_cord"; ("extend_from"),
"pody :
81
"body tep_sides_base base"; ["seamless")
There is sample DSL program collected from the fast prototyping of wheelbarrow design as follows.
1
2
"Parts":
3
"basin": {
"box_0;; ["height", "radius"],
"sphere_1"; ["height", "radius"]
,,
7
"fron_edge": {
8
"box_0": ("height", "radius"], "cylinder_1"; ("height", "radius"] ,
9
10
11
"hancles":
12
"cylinder_o"; ("radius", "height"],
13
*cylinder_1"; ["radius", "height"]
14
15
"supports":
"cylinder_0"; ("radius", "height"],
*cylinder_1"; ('radius", "height"] ,,
"frame": {
A6

---

Targeted control of fast prototyping through domain-specifie interface
"u "u_shape_ ["radius", "height"]
,,
22
"wheels": {
23
"cylinder_0"; ("radius", "height"],
24
"cylinder_1", ("radius", "height"]
25
)
26
"axle":
27
"cylinder_0" 0": ("radius", "height")
28
29
30
"Relationsii "Relationship":
31
"basin front_edge": "ssloped_doowwardd))
"basin handles": ["attached_to_reer""
"handles supports": ("connected"),
"frame <->
basin": |'nndernetta",,
"frame <-> wheels": ("symetrrial"),
"wheels <-> axle": ["through"],
37
"axle <-> frame": ("horizontal")
38
"axle <-> basin": ("behind feaall_foot___eeeeeeeeee edge"),
39
"handles <>> frame": ("rear_higherl
40
41
C.4. Success and failure cases
Success cases demonstrate the advancements of our interface and failure cases shape its boundary.
Success cases: (i) Our-Ints effectively maintains and guides the transformation of basic shapes and their modifications, mapping abstract designer instructions to concrete shape changes (see Fig. A3A); (ii) Our Inn can automatically infer a commonsense spatial distribution of components when designer instructions lack explicit spatial constraints (see Fig. A3B); and (iii) Our-Int translates modifications finer granularity, identifying which component and which attributes are affected (see Fig. A3C).
Failure cases: (i) for qualitative spatial constraints like "vertical" or "parallel", LLMs sometimes fail to map them correctly to precise positions and orientations due to their weak spatial reasoning (see Fig. A4A); and (ii) for certain abstract and complex instructions such operations involving Bezier curves-current methods sometimes fail to capture the correct approach (see Fig. A4B).
D. Implementation details
D.I. Computational cost
We leverage OpenAl's GPT-4o API the backbone LLM for both domain adaptation and runtime execution of the in- terface. Automatically designing domain-specific interface incurs average cost of approximately $10 per domain, with full adaptation across eight distinct domains. Operational costs during prototyping remain economical: executing the interface for targeted control consumes $0.3 per ten refinement iterations.
D.2. Implementation of MCMC sampling
The MCMC sampling process for construct expansion leverages LLMs as a dynamic proposal generator. For each seed construct (t), the proposal distribution q(L' (t)) is instantiated through LLM prompts that request domain-aware perturbations, such as: "Modify (current construct: handle length) to explore ergonomic variations, considering material constraints." The LLM generates candidate perturbations L', which are parsed into valid DSL construct samples. The acceptance probability estimated using the LLM''s likelihood scores for T/ versus I, (t) under domain-specific con-
A7

---

Targeted control of fast prototyping through domain-specifie interface
Our-Int
LLM-Int
w/o-Int
Attach dome-skaped the neck.
Shape the four tapered cylindrical forms.
Our-Int
LLM-Int
w/o-Int
spout the ride of the body.
Form custions into two parallel rectangular shapes.
Our-Int
LLM-Int
w/o-Int
Pouition two rotory dials the lower fooneffrnt front corners.
Recess dials into front pansf.
body.
Connect the handle the body longer motal piece.
Figure A3. Demonstrations of success
Our-Int
LLM-Int
w/o-Int
Place armreads perpendicular to the beckrest parallet the main frame.
Make the spout curved.
of the kandie.
Figure A4, Demonstrations of failure cases
texts. To ensure detailed balance, we maintain a buffer of rejected proposals for delayed acceptance. By initializing M parallel chains and performing steps per chain, the sampling process efficiently explores the combinatorial space of KC while preserving semantic diversity across domains.
A8

---

Targeted control of fast prototyping through domain-specifie interface
D.3. Feasibility validation via documentatiion-guieed RAG
The validation phase employs a Retrival-AAggmented Generation (RAG) system built from the modeling engine's program- matic documentation. First, we generate structured documentation by parsing the FreeCAD library's 's source code (hosted at https:
org/ Cat Ctte//tteegoooo// Developer httpeeepppr_occuetteeeeee www.mentation aton) using Doxygen (as suggested by the FreeCAD official website), extracting function signatures, parameter constraints, and geometric operation specifica- tions. This documentation is chunked into text segments and indexed in a vector store. During validation, each interface construct is converted to a natural language query (e.g., "Adjust cylindrical surface diameter") and used to retrieve the top-k relevant documentation entries. This RAG-driven process ensures the interface remains grounded in the modeling engine's 's actual capabilities, closing the loop between conceptual abstraction and technical executability.
Specifically, the mechanism of feedback generation evaluates constructs through both LLLM-as-a-judge analysis and CAD engine constraints (Zheng et al., 2023). It assesses three feasibility aspects and provides feedback to refine heuristics for subsequent iterations, all with minimal human intervention. First, designer language constructs (e.g., a "ring-shaped teapot body") cannot be translated into modeling operations. If construct is unsupported, heuristics such as pruning incompatible geometric primitives are applied and the LLM is prompted to propose alternative base shapes (e.g., torus segments, since CAD engines do not directly support a "ring"). A high frequency of such cases indicates that the constructs are overly abstract. Second, modeling constructs (e.g., sofa cushions formed by fusing two cylinders) lack equivalent high-level design terms. For missing constructs, heuristics like generating composite-shape directives (e.g., "create cushion from combined cylinders") are triggered in the next sampling iteration. A high occurrence of these cases suggests insufficient diversity in the designer's language. Third, no overlap between the finest designer constructs and the coarsest modeling operations. For mismatches (e.g., unsupported "material texture" operations), heuristics such as incompatibility pruning are employed, permanently removing non-viable constructs.
D.4. Updating of iteration
The optimization of Eq. (6) is achieved through iterations alternating construct expansion and feasibility validation. During the construct expansion phase, the heuristics adjust exploration strategies based on the interface's 's state and feedback from prior iterations. When diversity is insufficient (e.g., limited variation in designs), the heuristics broaden exploration breadth by prompting the LLM with directives like "generate diverse handle configurations for teapots". ". Conversely, if diversity is high, the heuristies narrow exploration breadth by prompting with constraints. When constructs are overly abstract (e.g-, "refine shape"), "), heuristics increase exploration depth by decomposing the constructs into atomic operations. If constructs are excessively granular, the heuristics reduce exploration depth by encapsulating low-level commands into functions (e.g., "smooth contour"). In the feasibility validation phase, heuristics enforce alignment with the modeling engine" 's capabilities by pruning constructs incompatible with CAD engine's 's constraints. This is now discussed in the revised manuscript.
Three intermediate metrics are leveraged to monitor the iterative process: (i) soundness, ensuring all language constructs used by designers can be implemented in the modeling process: (ii) completeness, ensuring all modeling process constructs represented in designers' language; (iii) granularity alignment, ensuring proper overlap between the finest-grained constructs in designers' language and the coarsest- grained constructs in the modeling process.
Under these intermediate metrics, we explore several alternative interfaces during the iterative process. The interfaces we examined are framed as (i) Single-MCMC: single-scale sampling without updating, sampling and clustering constructs within a single chain but lacks multi-chain diversity; (ii) Multi-MCMC: multi-scale sampling with updating, exploring diverse constructs via parallel chains but omits iterative optimization; and (iii) Ours: extending the previous two alternative interfaces by integrating multi-scale sampling and converged iterative refinement. Quantitative results support the design rationale of our interface (see Fig. A5). This superior systematic representation directly contributes to the improved final performance when integrated with an LLM for CAD.
E. Reproducibility
The project page with supplementary files for reproducing the results of this paper will be available at https: // //autodsl. wwwpodss...oooocceeeeeeeo wttpconnpppppppppecceeeeeeeeeeee html.
A9

---

Targeted control of fast prototyping through domain-specifie interface
Soundness domainss)
Completeness domains)
Grunalarity Aligament (All domains)
1.0
1.0
0.6
0.84
0.8-
0.2
0.6
0.6
MCMC Singk-MMMC
Ours
Mulú-MCMC
Singl-MMMCC
Ours
Mulli-MCMC
Single-MCMC
Figure A5. Quantitative results of the intermediate metrics
F. Limitations
As a representation of interface designed for a relatively under-researched problem, the design and evaluation of the proposed methodology come with limitations, leading to further investigations:
We currently model the interaction between industrial designers and the interface as a Markov Process, where each step of adjustment is only conditioned the last step. Can model the interactive process in sophisticated fashion, thereby taking the temporal dynamics along the process into consideration, such Bayesian updating, working memory, and the Aha! moment?
We presently regard NL instructions as the vehicle conveying the intentions of industrial designers. Can we include more types of medium for industrial designers' ideas, such as primal sketches on 2D plane, gesture trajectories in 3D space, or digital clays with surfaces covered by tactile sensors in higher degree-of-freedon as the input of our proposed interface?
Creating groundtruth-level modeling commands for target products requires the dedication of considerable efforts of experts. Can employ approach with higher extent of automation to reduce the cost groundtruth annotation, thereby broadening the scope of the products in the testing set, toward some small group domains of product?
With many questions unanswered, we hope to explore more on building interface for the targeted control of fast prototyping and beyond.
A10


Reviews:
[{"review_id": "jrOpvrQtud", "reviewer": "Reviewer_ugjZ", "summary": "This paper aims to address the problem of bridging industrial designers’ intuitive language and the precise modeling language of CAD modeling engines for fast prototyping. The authors introduce an interface (a domain-specific intermediate language) that translates designers’ natural-language instructions into modeling commands with sufficient granularity to capture design intent.\n\nThe authors propose a Domain Specific Language (DSL) approach that balances abstraction by mapping semantic parts and operations onto lower-level primitives. Results suggest the proposed interface yields better alignment between design intents and the actual modeling outcomes. The authors evaluate on two metrics: consistency and the clarity, and show that the DSL outperforms other baselines (e.g., directly prompting LLMs without interface).", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "> I'd happy to raise my score if the authors could expand on what makes the proposed method work better than the other baselines, especially why it's able to beat LLM based approach by significant margin. \n\n> It's not immediately clear to me why this method is the obvious approach over all other possibilities. \n\nThanks for the comment. Our work is not an alternative to LLM-based CAD generators, but rather an interface to improve the performance of LLM-based CAD generators by bridging designers' language with modeling engineers' language. The fundamental challenge is that while modeling languages are hierarchically documented, designers' language is unstandardized in the wild. This necessitates a systematic representation of concepts described in designers' language---from product categories to structures, components, attributes, and operations. This requirement aligns with word learning in cognitive science, where humans learn systems of interrelated concepts rather than isolated terms. \n\nDrawing inspiration from cognitive development, we mirror how people learn concept networks by sampling from the environment and organizing these samples into hierarchical structures through DPMM. This spectral clustering approach captures multi-level attributes rather than clustering based on overall similarity [1]. In our approach, we substitute environmental sampling with LLM-generated samples, as LLMs are recognized repositories of commonsense knowledge [2]. We then apply DPMM to cluster these samples into a hierarchy of structures, components, attributes, and operations. This systematic representation allows natural instructions from designers to be decomposed into fine-grained elements that align with modeling language constructs, enabling targeted control in fast-prototyping.\n\nTherefore, adding our interface to alternative approaches---such as forcing LLMs to directly translate between languages or inputting designers' instructions directly into LLM-based CAD generators, should intuitively benefit the performance. \n\n[1] Tenenbaum et al. How to grow a mind: Statistics, structure, and abstraction. Science, 2011.\n\n[2] Yildirim et al. From task structures to world models: what do LLMs know? Trends in Cognitive Sciences, 2024.\n\n> Lacks some analysis (ideally quantitative) and ablations on what advantage the proposed method has over the other baselines other than the final performance. \n\nThanks for the comment. In the revised manuscript, we establish a more comprehensive evaluation beyond the previous final performance, to guarantee the three major qualities of the LLM interface:\n\n(i) Soundness: ensuring all language constructs used by designers can be implemented in the modeling process;\n\n(ii) Completeness: ensuring all modeling process constructs are represented in designers' language; \n\n(iii) Granularity alignment: ensuring proper overlap between the finest-grained constructs in designers' language and the coarsest-grained constructs in the modeling process.\n\nQuantitative results for these metrics are available [here](https://anonymous.4open.science/api/repo/aidr-D5C2/file/cndk.pdf?v=e90f99d4), demonstrating the advancement of our interface. This superior systematic representation directly contributes to the improved final performance when integrated with an LLM for CAD. This analysis is now included in the revised manuscript.\n\n> The proposed method only compared to two other baselines, which seems a little slim to me. For example, the LLM prompting baselines could have very different performance if you prompt it differently.\n\nThanks for the comment. We would like to first clarify that our work is not proposing an alternative to LLM-based CAD generators, but rather an interface to improve the performance of LLM generators.\n\nOur approach is explicitly two-stage, with our interface serving as the first stage and LLMs for CAD as the second. To our knowledge, there are no established state-of-the-art baselines for direct comparison of the entire two-stage pipeline. Comprehensive baselines exist for the second stage, so we have adopted the current SOTA to evaluate the first stage, s.t. our proposed interface.\n\nWe fully acknowledge the reviewer's point about prompt sensitivity. Actually, this is also one of our major concerns. To address it, we designed our evaluation protocol to minimize the influence of varying prompts by inputting the same prompt to all compared pipelines for each design step. While this approach cannot completely eliminate prompt variability, it offers a straightforward comparison by controlling this variable as much as possible. Investigating the influence of different prompts represents a promising direction and is now discussed in the revised manuscript.", "claims_and_evidence": "The main claim is that there's a gap between the way industrial designers communicate design intent (high-level, domain-specific) and the low-level geometry-driven commands used in modeling engines and that the proposed method can bridge this gap. Experiments show that the proposed method outperforms other baselines.", "methods_and_evaluation_criteria": "The proposed method automatically generates DSL via iterative sampling from an LLM (treating the LLM as a store of commonsense domain knowledge). A hierarchical approach maps domain concepts and permissible operations onto the low-level geometry commands of modeling engines. Finally, an MCMC–style procedure refine and validate these DSL constructs against the actual CAD function calls. The method makes intuitive sense but has many moving parts and hyperparameters. It's not immediately clear to me why this method is the obvious approach over all other possibilities (e.g., the use of DPMM). \n\nEvaluation criteria are Rendering Consistency (evaluated by professional or trained designers) and Information Clarity. The evaluation protocol seems quite reasonable to me.", "theoretical_claims": "The authors do not propose theoretical claims in this paper.", "experimental_designs_or_analyses": "Strengths\n- The conducted experiments are reasonable and the results are significant.\n\nWeaknesses\n- Lacks some analysis (ideally quantitative) and ablations on what advantage the proposed method has over the other baselines other than the final performance. \n- The proposed method only compared to two other baselines, which seems a little slim to me. For example, the LLM prompting baselines could have very different performance if you prompt it differently.", "relation_to_broader_scientific_literature": "I fine the authors discussion on Relation To Broader Scientific Literature adequate and comprehensive.", "essential_references_not_discussed": "N/A", "other_strengths_and_weaknesses": "See Experimental Designs Or Analyses.", "other_comments_or_suggestions": "N/A", "questions_for_authors": "I'd happy to raise my score if the authors could expand on what makes the proposed method work better than the other baselines (beyond anecdotal observations), especially why it's able to beat LLM based approach by significant margin.", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "QpmAIdTIll", "reviewer": "Reviewer_TWHa", "summary": "This paper addresses the challenge of creating intuitive interfaces for industrial designers to control 3D prototype models using natural language rather than complex modeling commands. The paper seems to identify several gaps between \"designers' language\" and \"modeling languages\". For instance, designers may use high-level, semantic language (e.g., \"make the spout curve gently\"), while modeling languages use low-level, geometric commands. They propose an interface that serves as an intermediate DSL between designers' language and modeling commands. Their evaluation across eight product design domains shows their approach outperforms alternatives in rendering consistency and information clarity.", "questions": "", "limitations": "", "rating": 3, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "> The benchmarking metrics seemed like proxies to what would really matter?\n\nThanks for the question. Fast prototyping allowing designers to explore brainstormed ideas without elaborating their instructions into modeling engineers' language.  Our approach is explicitly two-stage, with our proposed interface serving as the first stage and LLM-based CAD generators as the second. Our metrics were selected to measure specific aspects of the process. Specifically, we use rendering consistency to measure how well the interface captures designers' intentions, essentially evaluating if desired elements appear and undesired ones are suppressed. Meanwhile, information clarity metrics quantify how effectively information transfers between designers' high-level language and modeling engineers' fine-grained requirements. We have clarified the rationale for these measurement approaches in the revised manuscript.\n\n> The work is heavily focused on a specific application domain with unclear generalizability to other spaces.\n\nThanks for the comment. Our main motivation is that fast prototyping allowing designers to explore brainstormed ideas without elaborating their instructions into modeling engineers' language, which in general investigates into the construction of a interface to bridge designers' language with modeling engineers' language. In broader context, our work provides a proof-of-concept for improving communication between domain-specific executors (Part-B) and stakeholders (Part-A). We totally agree that further investigation on generalization would be a promising direction. This is now discussed in the revised manuscript.\n\n> Limited discussion of computational efficiency and scalability; and lack of case studies useful in application papers.\n\n> Would like to see more qualitative examples to concretize a lot of the failures\n\nThanks for pointing these out. We have validated the computational efficiency by calculating the cost of targeted control, on the scale of eight domains.\n\nWe use OpenAI’s GPT-4o API for domain adaptation and real-time execution. Designing a domain-specific interface costs about \\\\$10 per domain, running 1,000 iterations on a MacBook with an M2 chip to ensure convergence. During prototyping, costs remain low: executing the pipeline for targeted control costs \\\\$0.10 for translation and \\\\$0.30 per ten refinement iterations for CAD generation.\n\nIn the revised manuscript, we add qualitative results on failure cases and success cases. **Due to the space limit, please refer to the response to the second question by reviewer h3kU.**\n\n> However, claims about the interface reducing cognitive load for designers aren't directly measured.\n\n> The paper claims their approach is generalizable across domains, but only tests on eight product categories which seem relatively similar.\n\nThanks for pointing out these confusions. We've revised our wording to emphasize the concrete benefit of \"reducing designers' manual efforts\" in fast prototyping. Regarding generalizability, we acknowledge our testing was limited to physical consumer products, a key reference for industrial design. To better reflect our scope, we've adjusted \"across domains\" to \"across categories\" in the revised manuscript.\n\n> The human study design with 50 participants is adequate, but I question whether 10 iterations per task is sufficient to capture the full design process.\n\nThanks for the question. Fast prototyping differs from full design. While full design requires master models for mass production, fast prototyping serves as an exploration for primary design ideas.\n\nDesign studies often use two setups: (i) counting iterations to reach certain resultsor (ii) evaluating improvements within a fixed iteration count. We adopt the latter to assess the improvements of each iteration with the same instruction, therefore relatively invariant to the number of iterations.\n\nThe current choice of 10 is informed by discussions with professional industrial designers to capture the typical lifecycle of fast prototyping, and would be further investigated in further study. This is now discussed in the revised manuscript.\n\n> This paper could benefit from discussing and/or connecting to such work!\n\nThanks for the insightful comment. Our automated interface design shares conceptual similarities with program synthesis in achieving hierarchical abstraction through iterative sampling and refinement. However, two key distinctions exist:\n\n(i) Knowledge representation: program synthesis relies on structured knowledge, using exemplar DSL programs to generate higher-level libraries. In contrast, our approach samples from unstructured commonsense knowledge bases (e.g., LLMs) and organizes knowledge into a DSL;\n\n(ii) Machine learning paradigm: program synthesis follows a supervised approach, leveraging I/O pairs with task specifications, whereas our method is unsupervised, emerging from commonsense knowledge bases.\n\nThis is now discussed in the revised manuscript.", "claims_and_evidence": "- The authors' claim that their interface improves targeted control is supported by comparative evaluations against alternative methods.\n- The human study provides reasonable evidence for the practical utility of the interface.\n- However, claims about the interface reducing cognitive load for designers aren't directly measured - this is inferred rather than demonstrated.\n- The paper claims their approach is generalizable across domains, but only tests on eight product categories which seem relatively similar (all being physical consumer products). I am not sure how this translates outside of this.", "methods_and_evaluation_criteria": "- The experimental setup using real design tasks with 50 participants is appropriate and relatively robust.\n- Using both rendering consistency and information clarity as metrics makes sense for evaluating the interface's practical utility.\n- However, something I'd maybe like to see is the evaluation on how the interface affects design iteration speed or quality of final designs - important metrics for any practical design tool (if that's the true goal since this is an application paper after all)", "theoretical_claims": "The paper doesn't present any formal theoretical proofs as such.The probabilistic hierarchical model appears valid, though I didn't verify all mathematical details.", "experimental_designs_or_analyses": "- The evaluation methodology comparing ranked preferences is reasonable, though somewhat subjective. \n- The human study design with 50 participants is adequate, but I question whether 10 iterations per task is sufficient to capture the full design process.\n- Would really like to see more qualitative examples to concretize a lot of the failures", "relation_to_broader_scientific_literature": "I am not too familiar with the literature close to this space, however, I am reminded of one approach from traditional program synthesis that seems relevant to consider. DreamCoder (Ellis et al., 2021) tackles learning program libraries via hierarchical representations and domain-specific languages. DreamCoder's approach of learning domain-specific languages through Bayesian program induction shares conceptual similarities with how this paper constructs their interface DSL.\nThe key parallels I see:\n- Both systems use hierarchical abstraction to bridge between high-level intentions and low-level execution\n- Both leverage iterative refinement of domain-specific languages\n\nThis paper could benefit from discussing and/or connecting to such work!", "essential_references_not_discussed": "--", "other_strengths_and_weaknesses": "Strengths:\n- The paper tackles a practical and interesting problem with clear real-world applications\n- The approach and experiments are sound and the human evaluation is good to see!\n\nWeaknesses:\n- The benchmarking metrics seemed like proxies to what would really matter? e.g.,  design iteration speed or quality of final designs\n- The work is heavily focused on a specific application domain with unclear generalizability to other spaces.\n- Limited discussion of computational efficiency and scalability; and lack of qualitative examples / case studies which I think are useful in application papers like these.", "other_comments_or_suggestions": "--", "questions_for_authors": "--", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "nzJZbDqnkx", "reviewer": "Reviewer_h3kU", "summary": "This paper proposes a systematic procedure that maps human designers' high-level modeling requirements to a domain-specific language that can be executed by software to render modeling prototypes more aligned with human intentions. By recognizing and mitigating the gaps between designer's language and modeling programming language, the authors propose a LLM-based target control method for fast prototyping. Through extensive experiments on fast prototyping involving human subjects, the authors justify their methodology and present a key finding, which is that the authors' pipeline enables precise and effective targeted control of prototype models.\n\n## update after rebuttal\n\nThis paper is clearer as the authors provide a detailed literature review to help the reviewer understand the studied topic better and provide qualitative analysis of the method limitations. Therefore, the score is raised to 4.\n\nI have read the comment by Reviewer tc7S and **believe the experiments should also provide more reproducible results, apart from the user studies conducted in the paper**. Nevertheless, this concern is not raised in my initial comment and will not affect my assessment.", "questions": "", "limitations": "", "rating": 4, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "> The authors have not provided a Related Work section in the main paper to present an overview of the studied topic.\n\nThanks for pointing this out. Now we incorporate a discussion contextualizing our work within the domain of targeted control in fast prototyping.\n\nFast prototyping is a key process in industrial design, enabling rapid iteration and tangible feedback without the constraints of production-level precision [1,2]. Unlike production-ready modeling carried out by engineers [3], fast prototyping prioritizes exploratory design adjustments, making intuitive and high-level control crucial [4]. Inspired by the concept of targeted therapy in medicine, targeted control in fast prototyping aims to maximize desired modifications while minimizing undesired distortions. This requires an interface that aligns with designers' high-level thinking, focusing on components, structures, and relationships rather than low-level modeling commands [5].\n\nExisting LLM-based CAD generators primarily assist modeling processes rather than fast prototyping, often requiring engineering-level language instructions or sketch instructions. For instance, Query2CAD refines CAD models through natural language queries [6], while Free2CAD translates sketches into CAD commands via sequence-to-sequence learning [7]. Recent advances leverage multi-modal capabilities, such as OpenECAD, which translates 3D design images into structured 2D and 3D commands [8], and CAD-Assistant, which employs tool-augmented vision-language models for general CAD tasks [9]. While these approaches enhance CAD generation and editing, they do not directly address the needs of fast prototyping.\n\nOur proposed interface complements existing LLM-based CAD generators by bridging this gap. Rather than directly alternating CAD generation models, it serves as an auxiliary module, enabling designers to exert precise, high-level control in fast prototyping workflows. This discussion is now included in the revised manuscript.\n\n[1] Burns, M. Automated fabrication: improving productivity in manufacturing. Prentice-Hall, Inc., 1993.\n\n[2] Hallgrimsson, B. Prototyping and modelmaking for product design. Laurenceking, 2012.\n\n[3] Barnhill, R. E. Geometry processing for design and manufacturing. SIAM, 1992.\n\n[4] Uusitalo, S. et al. \"clay to play with\": Generative ai tools in ux and industrial design practice. In ACM DIS, 2024.\n\n[5] Hannah, G. G. Elements of design: Rowena Reed Kostellow and the structure of visual relationships. Princeton Architectural Press, 2002.\n\n[6] Badagabettu A. et al. Query2cad: Generating cad models using natural language queries. arXiv, 2024.\n\n[7] Li C. et al. Free2cad: Parsing freehand drawings into cad commands. ACM Transactions on Graphics, 2022.\n\n[8] Yuan Z. et al. OpenECAD: An efficient visual language model for editable 3D-CAD design. Computers & Graphics, 2024.\n\n[9] Mallis D. et al.CAD-Assistant: Tool-Augmented VLLMs as Generic CAD Task Solvers?. arXiv, 2024.\n\n> Failure case analysis is also not presented to help the readers to understand the limitations of the proposed method.\n\nThanks for pointing this out. We have qualitative results as follows. The results are presented through links. Failure cases shape the boundary of our method and success cases .\n\nFailure cases:\n\n(i) For qualitative spatial constraints like \"vertical\" or \"parallel\", LLMs sometimes fail to map them correctly to precise positions and orientations due to their weak spatial reasoning. \n\n[failure case 1](https://anonymous.4open.science/api/repo/aidr-D5C2/file/failure_cases_1-1.pdf?v=e8fc2083)\n\n(ii) For certain abstract and complex instructions---such as operations involving Bezier curves---current methods sometimes fail to capture the correct approach. \n\n[failure case 2](https://anonymous.4open.science/api/repo/aidr-D5C2/file/failure_cases_2-1.pdf?v=2309fa9d)\n\nSuccess cases:\n\n(i) Our-Int effectively maintains and guides the transformation of basic shapes and their modifications, mapping abstract designer instructions to concrete shape changes. \n\n[success case 1](https://anonymous.4open.science/api/repo/aidr-D5C2/file/success_cases_1.pdf?v=9ff7813b)\n\n(ii) Our-Int can automatically infer a commonsense spatial distribution of components when designer instructions lack explicit spatial constraints. \n\n[success case 2](https://anonymous.4open.science/api/repo/aidr-D5C2/file/success_cases_2.pdf?v=8f009633)\n\n(iii) Our-Int translates modifications at a finer granularity, identifying which component and which attributes are affected. \n\n[success case 3](https://anonymous.4open.science/api/repo/aidr-D5C2/file/success_cases_3.pdf?v=7755eada)\n\nThese analyses are now included in the revised manuscript.", "claims_and_evidence": "Yes, the claims made in the submission are supported by clear and convincing evidence.", "methods_and_evaluation_criteria": "Yes, the proposed methods and evaluation criteria make sense for the problem or application at hand.", "theoretical_claims": "Yes. The formulas in Section 3 are correct.", "experimental_designs_or_analyses": "Yes. The experimental details and analysis in Section 4 are solid.", "relation_to_broader_scientific_literature": "The key contribution of this paper is a systematic way of transforming human designers' language into a domain-specific programming language for fast prototyping. As I'm not adept at computer-assisted designing, I'm not sure whether this paper is related to broader scientific literature.", "essential_references_not_discussed": "No.", "other_strengths_and_weaknesses": "Strengths:\n\n1. This paper is targeted at the application of large language models in computer-assisted design. This topic is interesting and valuable for the industry.\n\n2. The paper proposes an LLM-based fast prototyping method, which is novel and justified by the experiments.\n\n3. The paper provides extensive qualitative and quantitative experiments, which are very solid with detailed statistical analysis.\n\nWeaknesses:\n\n1. The authors have not provided a Related Work section in the main paper to present an overview of the studied topic.\n\n2. Failure case analysis is also not presented to help the readers to understand the limitations of the proposed method.", "other_comments_or_suggestions": "The rating can be raised if the concerns are to be addressed.", "questions_for_authors": "None", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "4sW0OZs0WP", "reviewer": "Reviewer_tc7S", "summary": "This paper proposes an LLM-based approach to translating designer's language to CAD language. The authors propose the approach of first translating the designer's instructions into an intermediate language called modeling language, and then translating the instruction in modeling language to CAD. To achieve this, the authors propose various sampling methods to generate several samples from the LLM, and then pick the sample with the highest score (based on three criteria (1) point-to-point implementation, (2) hierarchical decomposition, (3) incompatibility pruning). Finally, the authors show the superiority of their method compared to one-shot LLM-generation baselines via a user study.", "questions": "", "limitations": "", "rating": 2, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "> Is there any way to automatically benchmark the effectiveness of your method?\n\nThanks for the comment. We would like to clarify that we aim to directly assess the targetedness of each individual design instructions, e.g., \"make the spout narrower\". This measure is somewhat subjective, as designers must evaluate whether desired changes were implemented while undesired changes were suppressed.\n\nOur work requires step-by-step assessment of each instruction within a sequence leading to a final product, whereas existing datasets typically evaluate only the final result after multiple instructions. This fundamental difference means that while conventional methods can create groundtruth references in advance, our approach relies on designers' on-the-fly instructions, making it impractical to prepare ground truth data (e.g., point clouds) beforehand. This is now discussed in the revised manuscript.\n\n> Can you elaborate on how the objective in Eq. 6 is optimized?\n\nThanks for the question. The optimization of Eq. 6 is achieved through iterations alternating construct expansion and feasibility validation. During the construct expansion phase, the heuristics adjust exploration strategies based on the interface’s state and feedback from prior iterations. When diversity is insufficient (e.g., limited variation in designs), the heuristics broaden exploration breadth by prompting the LLM with directives like “generate diverse handle configurations for teapots”. Conversely, if diversity is high, the heuristics narrow exploration breadth by prompting with constraints. When constructs are overly abstract (e.g., “refine shape”), heuristics increase exploration depth by decomposing the constructs into atomic operations. If constructs are excessively granular, the heuristics reduce exploration depth by encapsulating low-level commands into functions (e.g., “smooth contour”). In the feasibility validation phase, heuristics enforce alignment with the modeling engine’s capabilities by pruning constructs incompatible with CAD engine's constraints. This is now discussed in the revised manuscript.\n\n> There are various sampling techniques used in the paper that are not ablated. I would suggest the authors consider the following baselines:...\n\nThanks for the suggestion. In selecting our interfaces, we explored several alternative methods and evaluated them using intermediate metrics (soundness, completeness, and granularity alignment) that contribute to final performance. The methods we examined are framed as Single-MCMC (single-scale sampling with ranking) and Multi-MCMC (multi-scale sampling with reranking). Specifically:\n\n(i) Single-MCMC aligns with the first suggested baseline for sampling and ranking constructs within a single chain but lacks multi-chain diversity.\n\n(ii) Multi-MCMC mirrors the second suggested baseline for exploring diverse constructs via parallel chains but omits iterative optimization.\n\n(iii) Our full method (Converged MCMC) extends these by integrating multi-scale sampling and iterative refinement. \n\nResults are available [here](https://anonymous.4open.science/api/repo/aidr-D5C2/file/klsdhf.pdf?v=5ecb1bc1), validating our design choices. This analysis is now included in the revised manuscript.\n\n> The related work discussion is very concise.\n\n**Due to the space limit, please refer to the response to the first question by reviewer h3kU.**\n\n> I find the reranking and sampling method in the paper interesting, but (1) very few baselines are considered, and (2) the evaluation is only based on an unreproducible user study.\n\nThanks for the comment. Regarding the concerns about baselines, we'd like to clarify that our work is not proposing an alternative to LLM-based CAD generators, but rather an interface to improve the performance of those generators. This functions as the first stage of an explicit two-stage approach, with LLM-based CAD generators serving as the second stage. To the best of our knowledge, there are no established baselines for this complete two-stage pipeline. We have incorporated state-of-the-art methods for the second stage.\n\nConcerning reproducibility, we acknowledge that different prompts can yield different results. To address this, we input identical design instructions to all compared pipelines in each design step. While this cannot completely eliminate prompt-dependent variations, it represents our best effort to standardize the experimental protocol for measuring the inherently subjective concept of targetedness, providing a reasonable foundation for comparison. This is now discussed in the revised manuscript.\n\n> I suggest the authors provide more documents on their user study, and the final figures generated for each method.\n\nThanks for the suggestion. The records are available [here](https://anonymous.4open.science/api/repo/aidr-D5C2/file/chkasd.pdf?v=4450cee7), which are now included in the revised manuscript.", "claims_and_evidence": "* There are various sampling techniques used in the paper that are not ablated, such as first using MCMC, and then using expectation maximization. These two methods are not completely ablated, and their benefit does not seem very clear to me. To me, it seems that the benefit is coming from taking multiple samples from the LLM, and then ranking the samples, but the baselines are one-shot, and without chain-of-thought. I would suggest the authors consider the following baselines: (1) Taking multiple samples from the LLM, and ranking them based on the criteria above Eq. 6, (2) Few-shot prompting the model to generate the intermediate language and then reranking the responses based on criteria above Eq. 6. This way, the contribution of each part of the method becomes more clear.", "methods_and_evaluation_criteria": "* The evaluated dataset is more of a user study, rather than a reproducible quantitative benchmark. This makes future comparisons harder. Especially given that the authors did not disclose what prompts the users input to the LLM, and what response they got.", "theoretical_claims": "NA", "experimental_designs_or_analyses": "* See Claims And Evidence for the missing experiments.", "relation_to_broader_scientific_literature": "Facilitating CAD design using LLMs could be an important problem, and the proposed methods, if effective, could potentially be used in other domains.", "essential_references_not_discussed": "The related work discussion is very concise, and the authors only cite papers, rather than positioning their work in comparison to those papers. Two works that are cited, seem very relevant to this work, and are not discussed are (Wu et al., 2023) and (Yuan et al., 2024) in the paper.", "other_strengths_and_weaknesses": "Overall, I find the reranking and sampling method in the paper interesting, but (1) very few baselines are considered, and (2) the evaluation is only based on an unreproducible user study.", "other_comments_or_suggestions": "* I suggest the authors provide more documents on their user study such as individual prompts, and the final figures generated for each method.", "questions_for_authors": "1. Is there any way to automatically benchmark the effectiveness of your method? I am not familiar with CAD design, but I saw a related work [1] evaluating their method using some metrics, such as point cloud distance to a ground-truth label.\n\n2. Can you elaborate on how the objective in Eq. 6 is optimized? Do the authors use heuristics?\n\n[1] Alrashedy et al., Generating CAD Code with Vision-Language Models for 3D Designs 2024", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: This paper proposes a novel interface architecture using a Domain-Specific Language (DSL) to bridge the gap between high-level natural language instructions from industrial designers and low-level commands for CAD modeling engines during fast prototyping. The core idea involves using LLMs to generate and refine this intermediate language. The paper received a mixed reception from reviewers, with scores of 4 (Accept), 3 (Weak Accept), 3 (Weak Accept), and 2 (Weak Reject).

Strengths: 

Reviewers generally agreed that the paper tackles an important and practical problem in CAD/design (Reviewers TWHa, h3kU). The proposed approach of using an intermediate DSL generated via LLMs was considered novel (h3kU). The inclusion of human studies demonstrating potential utility was also seen positively (ugjZ, TWHa).

Weaknesses & Concerns: 

Initial concerns included a lack of clarity on why the method outperforms baselines (ugjZ), limited baseline comparisons and potential prompt sensitivity (ugjZ, tc7S), evaluation metrics being proxies for real-world design speed/quality (TWHa), limited generalizability testing (TWHa), lack of qualitative failure analysis and related work (h3kU), and concerns about the evaluation methodology's reproducibility (user study focus) and ablation of sampling techniques (tc7S). Reviewer tc7S, lacking CAD expertise, also found the paper difficult to follow and questioned the novelty beyond multi-sampling/reranking techniques common in LLMs.

Post Rebuttal & Discussions: 

The authors provided detailed rebuttals, clarifying the interface's role (auxiliary module, not replacement), adding related work, qualitative examples (success/failure), details on efficiency, new intermediate evaluation metrics (soundness, completeness, granularity) with ablation results for their MCMC-based approach, and justifying the user study design for fast prototyping. This satisfied Reviewer h3kU (score maintained at 4) but did not convince Reviewer tc7S (score remained 2), who still found the explanations unclear, questioned the MCMC necessity, and remained concerned about reproducibility and the assessment of CAD-specific contributions. Reviewers ugjZ and TWHa acknowledged the rebuttals but did not change their scores (3).

While the paper addresses a relevant application and presents a novel approach with promising initial results (including a positive review from h3kU post-rebuttal), significant concerns remain. Crucially, Reviewer tc7S raises persistent issues regarding methodological clarity, the rigor and reproducibility of the evaluation (heavy reliance on user studies and LLM-as-judge), and the impact of having or not having CoT in the process that seems unfair, and the clear delineation of novelty beyond established LLM sampling techniques. Although the authors provided extensive rebuttals and added content, these did not resolve the core concerns for this reviewer. The other two reviewers remained weakly positive (3). Given the unresolved methodological questions and the split opinions, particularly the strong concerns from an LLM perspective (tc7S), the paper currently sits on the borderline.
Decision: Accept (poster)