LLM-Assisted Design Systems

• Large Language Model-Assisted Design is a workflow where LLMs augment human design processes by proposing, classifying, and refining structured artifacts such as CAD models and algorithms.
• Design workflows integrate iterative LLM prompts, context retrieval, validation stages, and external tool executions to enable meta-optimization and ensure semantic consistency.
• This approach has demonstrated notable improvements in performance metrics across EDA, CAD, and hardware domains, fostering novel capabilities in algorithm synthesis and automated design.

LLM-Assisted Design denotes a class of workflows in which a LLM participates directly in the creation, refinement, evaluation, or orchestration of a designed artifact, rather than serving only as a general chatbot or a one-shot code generator. In the cited literature, this role ranges from idea exploration, dialogue with designers, and design evaluation, to meta-optimization of algorithms, generation of CAD and HDL artifacts, orchestration of EDA and CAE toolchains, and literature-grounded engineering discovery. Across these settings, the LLM is typically embedded in a structured loop with prompts, retrieved context, external tools, validation stages, and iterative feedback, so that design becomes a closed, inspectable, and partially automatable process rather than an isolated text-generation event (Panda, 11 Feb 2025, Yang et al., 16 Sep 2025, Sestito et al., 20 Jan 2026, Guo et al., 14 Sep 2025).

1. Human-in-the-loop design assistance

A foundational strand of the field treats the LLM as a design assistant that augments, rather than replaces, human judgment. “A Framework for LLM-powered Design Assistants” identifies three process-agnostic modalities—Idea Exploration, Dialogue with Designers, and Design Evaluation—and explicitly frames the LLM as a support tool inserted at different checkpoints of a design process while preserving designer control (Panda, 11 Feb 2025). This formulation is broad enough to cover early ideation, interactive clarification of ambiguous requirements, and later-stage critique.

Several systems instantiate this principle in narrowly defined authoring environments. “MenuCraft” turns menu-system design into a dialogue in which GPT-3.5-turbo assists with command placement and order, tab naming, hotkey assignment, and iterative refinement through in-context learning. Its emphasis is on semantic and systematic relations among commands, cross-menu consistency, and an interaction style in which the designer can correct the model in plain language and accumulate session-specific constraints (Kargaran et al., 2023). “Assisted Debate Builder with LLMs” similarly uses open-source LLMs as plugins in a structured authoring workflow: the human edits a debate tree, while the system verifies whether an argumentative relation is attack or support and exposes label probabilities through LMQL-constrained outputs. In that setting, the LLM functions as a relation-based argument-mining component inside a human-controlled debate-construction process, rather than as an autonomous writer (Faugier et al., 2024).

These systems collectively reject a common misconception: LLM-assisted design is not identical to unconstrained text generation. In the assistant paradigm, the artifact under construction has explicit structure—menus, debate trees, or design rationales—and the model’s role is to propose, critique, classify, or clarify within that structure. This suggests that the decisive capability is not fluency alone, but the ability to participate in a formally constrained authoring loop.

2. Recurrent architectures and workflow patterns

A second strand of the literature focuses on the architecture of LLM-assisted design systems. “LLM4AD: A Platform for Algorithm Design with LLM” formalizes a modular platform with three main blocks—Search methods, LLM interface, and Task evaluation interface—together with a unified evaluation sandbox. Search is iterative and population-based: candidate algorithms are evaluated, elites survive, the LLM proposes new variants, and the cycle repeats. The platform integrates methods such as Sampling, tabu search, simulated annealing, EoH, FunSearch, (1+1)-EPS, MEoH, NSGA-II, and MOEA/D, while standardizing LLM access and safe execution of generated code (Liu et al., 2024).

More agentic architectures push the LLM further into orchestration. “LLM-empowered next-generation computer-aided engineering” defines a CAE agent through four modules—analysis files, tools, online resources, and context window—so that the model can plan a workflow, execute tool calls, monitor failures, and adapt the procedure rather than merely invoking fixed software functions (Guo et al., 14 Sep 2025). “A flexible LLM-assisted electronic design automation framework” places the LLM inside a four-stage closed loop of Prompt input, LLM source-file generation, EDA tool execution, and Report parsing and feedback. The generated artifacts are tool-ready source files for commercial environments such as Cadence Virtuoso Spectre, Keysight ADS, and AMD Vivado, and the loop uses output reports to drive later iterations (Sestito et al., 20 Jan 2026).

A similar orchestration principle appears in “NL2GDS: LLM-aided interface for Open Source Chip Design,” where natural-language hardware intent is converted into synthesizable RTL and then into GDSII through OpenLane. The framework includes clarification dialogue, a Verilog Generation Agent, verification via Verilator lint mode, retrieval-augmented configuration generation, and backend-aware refinement driven by flow logs and metrics (&&&10&&&). Taken together, these systems establish a characteristic pattern: the LLM rarely operates alone. It is embedded in a modular pipeline that separates generation, execution, validation, and feedback, thereby converting language-based design assistance into a repeatable engineering workflow.

3. Representation, prompting, retrieval, and solver coupling

The effectiveness of LLM-assisted design depends heavily on how the design problem is represented to the model. One response is formal prompt protocol design. In “LLM-assisted Meta-optimizer for Automated Design of Constrained Evolutionary Algorithm,” the $RTO^2H$ framework standardizes prompts into Role Definition, Task Description, Operating Requirement, History Feedback, and Output Format. This prompt protocol converts an open-ended LLM into a controlled meta-design system for generating update rules of constrained evolutionary algorithms (Yang et al., 16 Sep 2025).

Another response is to redesign the artifact language itself. “CAD-Llama” introduces Structured Parametric CAD Code (SPCC), a Python-like code representation enriched with hierarchical semantic descriptions. Local component descriptions, global model descriptions, and short component names are inserted directly into the code sequence, and adaptive pretraining plus instruction tuning then align LLaMA3-8B-HF to CAD-specific tasks. The reported ablation results indicate that hierarchical descriptions, code-like format, and their combination each improve downstream CAD performance, with SPCC performing best overall (Li et al., 7 May 2025). “A Solver-Aided Hierarchical Language for LLM-Driven CAD Design” reaches a similar conclusion from a different direction. Its AIDL language is hierarchical and solver-aided: the LLM expresses structures, parameters, and geometric constraints, while a geometric constraint solver resolves the spatial reasoning burden. The paper explicitly states that an AIDL model is valid if geometry references remain within the same structure and constraint references remain within the same subtree, thereby making hierarchical constraint solving tractable (Jones et al., 13 Feb 2025).

Retrieval-grounded prompting supplies a third pattern. “Ask-EDA” combines dense retrieval with BM25 sparse retrieval, fuses rankings through reciprocal rank fusion with $k=60$, and augments prompts with Abbreviation De-Hallucination (ADH) to suppress incorrect acronym expansion in electronic design contexts (Shi et al., 2024). This suggests that representation is not limited to the output language: it also includes how design context, history, terminology, and retrieved evidence are serialized into promptable form. A plausible implication is that many reported gains in LLM-assisted design derive less from raw model scale than from representational engineering that aligns the design artifact with the model’s strengths.

4. Automated algorithm and optimizer design

The most explicit shift from “using” an algorithm to “designing” one appears in LLM-assisted algorithm search. “LLM-assisted Meta-optimizer for Automated Design of Constrained Evolutionary Algorithm” proposes AwesomeDE / llmEA, a MetaBBO-style bi-level framework in which the LLM generates the update rule $\mathcal{F}$ of a constrained evolutionary algorithm without human intervention in the rule-writing step. The inner loop applies $\mathcal{F}$ to a population, while the outer loop archives elite rules and historical trajectories and feeds performance back into the LLM for iterative refinement. The constrained optimization problem is written in the standard form

$$\text{Minimize } f(\mathbf{x}), \quad \mathbf{x} \in S \subseteq \mathbb{R}^D$$

subject to

$g_i(\mathbf{x}) \le 0,\quad 1 \le i \le p,$

$$|h_j(\mathbf{x})| \le \epsilon,\quad p+1 \le j \le m,$$

with equality tolerance $\epsilon = 10^{-4}$ (Yang et al., 16 Sep 2025).

The reported results indicate that llmEA achieves the best performance on six CEC2010 benchmark functions—C02, C09, and C14–C18—and reduces average minimum objective values by 55.1%–96.5% relative to the second-best method on the hardest high-dimensional constrained cases. It is also reported as the only method to find feasible solutions on C09, C14, and C15, and to obtain feasible solutions on 66.7% of test functions, compared with 33.3%–50% for other algorithms (Yang et al., 16 Sep 2025). These figures are significant because the paper’s claim is not merely that an LLM can tune hyperparameters, but that it can synthesize the search operator itself.

A complementary perspective is provided by “Fitness Landscape of LLM-Assisted Automated Algorithm Search,” which analyzes LLM-assisted algorithm search (LAS) as a graph-based fitness landscape. Candidate algorithms are nodes, parent-offspring generation events define directed edges, and the resulting sampled landscape is characterized by density, average degree, and clustering coefficient. The paper reports that LAS landscapes are highly multimodal and rugged; in heuristic design tasks such as OBP, TSP, CVRP, and often VRPTW, around 80% of algorithms lie in the lowest 20% of fitness values, whereas in symbolic regression about 98% of algorithms remain far from optimal. It also shows that population size changes the exploration-exploitation trade-off and that different LLMs induce different local clustering and sparsity patterns (Liu et al., 28 Apr 2025).

“LLM4AD” supplies the infrastructural counterpart to these studies by making search methods, tasks, and LLM backends interchangeable under a common pipeline and sandbox (Liu et al., 2024). A central conclusion across these works is that LLM-assisted algorithm design is not reducible to generic code synthesis. It is a search process over programmatic artifacts in which prompt design, population management, fitness evaluation, and landscape structure determine whether the LLM behaves as a productive meta-optimizer or as a brittle generator.

5. Geometric, hardware, and manufacturing design

In CAD and hardware design, LLM-assisted design frequently appears as translation from informal intent into executable design artifacts plus iterative repair. “From English to ASIC” fine-tunes Mistral 7B with LoRA on a labeled Verilog corpus built from 68,122 Verilog entries. On 143 VerilogEval-Machine problems, the fine-tuned model reaches pass@1 = 40.59%, pass@5 = 43.42%, and pass@10 = 44.24% at temperature 0.2, compared with 18.11%, 34.86%, and 41.19% for the base Mistral-7B-v0.1. The paper also notes persistent limitations: hallucinations, missing endmodule, wrong-language output, and weak performance on finite state machines, larger circuits, and shift registers (Goh et al., 2024).

The broader front-end EDA literature increasingly frames this translation problem as a staged, feedback-driven flow. “LLM for EDA in Front-End Design: Challenges and Opportunities” organizes the evolution from S1: Assisting to S5: Autonomy and reviews methods such as VRank, VFocus, AutoBench, CorrectBench, ConfiBench, HLSRepair, HLSTester, and HLSRewriter. It reports a 10.5% functional-correctness improvement on VerilogEval for VRank, 30.9% improvement over the DeepSeek-R1 baseline for VFocus, 57% improvement in pass@1 over direct full-testbench generation for AutoBench, 70.13% overall pass rate for CorrectBench compared with 52.18% for AutoBench, 72.22% overall pass rate for ConfiBench, 23.33% improvement in repair pass rate for HLSRepair, 2.71× higher testing efficiency for HLSTester, and average reductions of 24.99% area, 12.69% power, and 18.34% latency for HLSRewriter (Xu et al., 10 Jul 2026). These results reinforce the importance of decomposition, shared specifications, and closed-loop verification.

At larger system scope, “LaMDA” shows how LLMs can drive commercial EDA tools across analog, RF, and FPGA workflows. In the OTA case study, the framework generates Spectre decks, performs 15 bias sweeps, and identifies operating points meeting gain $> 40\ \mathrm{dB}$, phase margin $> 60^\circ$, and UGB around $k=60$0. In the microstrip patch antenna case, it reaches $k=60$1 at iteration 9 and $k=60$2 at iteration 10. In the FPGA/ResBench study, 73% of problems pass at least one implementation run out of five, 45% satisfy the LUT objective at least once, and 20% meet the clock-frequency or maximum-delay objective at least once (Sestito et al., 20 Jan 2026). “NL2GDS” extends this logic through OpenLane to full layout generation, reporting area reductions up to 36%, delay reductions up to 35%, and power savings up to 70% relative to baseline designs on ISCAS’85 and ISCAS’89 benchmarks, together with a 3.46× speedup from parallel orchestration in one OpenLane study (Eland et al., 5 Mar 2026).

In geometric design, “CAD-Llama” adapts LLaMA3-8B-HF to parametric CAD generation through SPCC-based adaptive pretraining and instruction tuning, achieving $k=60$3 and Average = 63.58% across captioning, completion, addition, and deletion tasks, well above GPT-4, GPT-3.5, LLaMA3, and Mistral baselines (Li et al., 7 May 2025). A different route is taken by AIDL, where the LLM generates solver-aided hierarchical CAD code and the solver enforces geometric constraints; AIDL reports average CLIP score 28.90, compared with 27.32 for OpenSCAD in the few-shot comparison (Jones et al., 13 Feb 2025). Mechanical design assistance exhibits the same pattern at smaller scale: “Constructing Mechanical Design Agent Based on LLMs” argues that direct prompting is unreliable for complex parts, and instead proposes a six-stage workflow—Foundational Code Learning, Key Feature Extraction, Feature Analysis, First Evaluation, Part Parameterization, Final Evaluation—centered on OpenSCAD and ChatGLM (Lu et al., 2024). Across these works, the recurring thesis is that executable geometry and hardware design demand structured representations, iterative checking, and tool-aware repair.

6. Knowledge-grounded engineering and scientific discovery

Not all LLM-assisted design systems generate artifacts directly. A substantial subfield uses LLMs to mediate technical literature, terminology, and datasets so that design decisions can be grounded in external evidence. “Ask-EDA” is a domain-specific chat agent for electronic design engineers that combines hybrid RAG with ADH over a knowledge base of about 400 MB of internal content, including 10,200 command manual pages, 5,000 parameters, 30 Slack channels, and 18,000 Q&A pairs. On q2a-100, hybrid RAG yields over a 40% improvement in Recall compared to no RAG; on cmds-100, it yields over a 60% improvement in Recall; and on abbr-100, ADH yields over a 70% enhancement in Recall (Shi et al., 2024).

“MuaLLM” generalizes this pattern to circuit design assistance through a multimodal, ReAct-based agent coupled to a hybrid contextual RAG pipeline and an adaptive vector database. It separates retrieval from inference, indexes text and image descriptions in a unified vector database, can fetch new papers dynamically, and reports 90.1% recall on RAG-250 and 86.8% accuracy on Reas-100. At the maximum context length supported by standard LLMs, it is reported as up to 10x less costly and 1.6x faster than direct full-context prompting while maintaining the same accuracy (Abbineni et al., 11 Aug 2025). This architecture treats literature review itself as an engineering design primitive.

Materials-design papers extend the same logic into inverse design and property prediction. “Inverse Materials Design by LLM-Assisted Generative Framework” uses Uni-SMART for LLM-assisted literature mining from over 200 published sources, creating a dataset of 1,338 entries with 26 thermodynamic features per alloy entry. That expanded dataset supports a conditional GAN for alloy generation, and experimental validation on Zr-based metallic glasses reports maximum thermodynamic-property deviations of 5.8% and 7.7%, supporting the paper’s claim of discrepancies below 8% (Hao et al., 25 Feb 2025). “LLM Assisted Discovery of Optimal Dopants for Enhanced Thermoelectric Performance in CoSb$k=60$4 Based Skutterudites” uses bert-base-uncased to extract a 768-dimensional [CLS] embedding from composition-temperature strings, with positional embeddings zeroed out for permutation invariance. On a curated dataset of 412 experimental results from over 300 published research articles, the BERT-based regressor achieves best MSE = 0.0373 and best $k=60$5, compared with 0.0644 and 0.7824 for the ANN baseline; downstream DFT and MD calculations then support a high-performing Ce-In-Ba-filled candidate (Bandyopadhyay et al., 7 Apr 2026). These cases show that LLM-assisted design can operate upstream of generation by converting fragmented technical literature into structured design knowledge.

7. Evaluation, limitations, and research directions

The literature is unusually explicit about limitations. A first recurring issue is that LLM-assisted design should not be conflated with generic coding competence. “LLM4AD” reports that better code-generation scores on benchmarks like HumanEval do not necessarily imply better algorithm-design performance (Liu et al., 2024). In EDA, “LLM for EDA in Front-End Design” argues that the real difficulty is semantic consistency across heterogeneous representations: a syntactically correct HDL fragment may still violate the original specification, and the error can propagate downstream (Xu et al., 10 Jul 2026). In CAD and mechanical design, direct prompting remains unstable for complex objects, which is why staged teaching, hierarchical DSLs, and solver coupling recur so often (Lu et al., 2024, Jones et al., 13 Feb 2025).

A second limitation is context scale and token economy. AwesomeDE notes that input-length constraints limit scalability for large constrained optimization problems because the prompt must carry enough history and problem context to remain useful (Yang et al., 16 Sep 2025). LaMDA reports that one RF system prompt was initially around 128,000 tokens and had to be reduced to about 26,000 tokens by automating repetitive operations and retaining only design-dependent knowledge (Sestito et al., 20 Jan 2026). The front-end EDA survey likewise identifies high token consumption and low execution efficiency as major obstacles for agentic systems (Xu et al., 10 Jul 2026). This suggests that scalable LLM-assisted design depends on prompt compression, sparse attention, dynamic context pruning, retrieval decoupling, and persistent external memory.

A third limitation is verification and reliability. “LLM-Aided Efficient Hardware Design Automation” emphasizes hallucination, limited hardware-specific understanding, privacy and security, long-context limitations, and tool incompatibility, even while arguing that LLMs can act as an intelligent agent layer over EDA tools (Xu et al., 2024). “How Can LLMs Help Humans in Design and Manufacturing?” reaches a parallel conclusion in CAD/CAM and robotics: GPT-4 is useful as an interface layer across specification, manufacturing instructions, performance estimation, and search, but remains weak at exact geometry, arithmetic accuracy, verification, and large numbers of simultaneous constraints (Makatura et al., 2023). The process-agnostic design-assistant framework similarly assumes that designers remain responsible for final judgment and that the framework is conceptual rather than empirically validated (Panda, 11 Feb 2025).

Future directions in the cited works are correspondingly concrete. AwesomeDE proposes sparse attention, dynamic context pruning, transfer learning, and extension to multi-objective and dynamic constrained optimization (Yang et al., 16 Sep 2025). The front-end EDA survey calls for better datasets and knowledge bases, specification refinement, collaborative multi-agent systems, and resource-efficient models (Xu et al., 10 Jul 2026). The CAE-agent literature argues for LLMs that synthesize intrusive MOR solvers from natural-language PDE descriptions, thereby making data-free model order reduction practical and broadly accessible (Guo et al., 14 Sep 2025). AIDL implies a related design principle at the language level: rather than forcing the model to solve all spatial reasoning internally, one can build a graphics or CAD system tailored for LLMs and delegate exact constraint satisfaction to an external solver (Jones et al., 13 Feb 2025).

Viewed together, these works define LLM-assisted design as a heterogeneous but technically coherent research area. Its core proposition is not that LLMs can replace domain tools or expert designers, but that they can become semantic interfaces, structured proposal engines, and workflow orchestrators across algorithm design, CAD, EDA, CAE, and scientific discovery. The strongest results arise when the model is grounded by explicit representations, coupled to validators and solvers, and embedded in closed loops where generated artifacts are executed, measured, and revised.