Implementing LLM-Empowered CAD: Paths and Engineering Practices

    This article explores the engineering practices of integrating large language models (LLMs) into Computer-Aided Design (CAD). It covers converting natural language into executable design intent, adopting a layered architecture, managing local modifications, ensuring 2D and 3D semantic consistency, establishing execution loops, implementing layered engineering validation, and maintaining data governance. It provides a practical guide to building a stable and maintainable intelligent design system that combines deterministic geometric computation with LLM intent understanding.

    I. From “Generating Scripts” to “Completing Engineering Tasks”

    Computer-Aided Design (CAD) has long relied on professionals to execute commands, set parameters, and maintain model constraints. For users familiar with engineering objectives but not software operation details, there remains a significant barrier between expressing requirements and obtaining a usable model.

    Large language models (LLMs) offer a new interaction paradigm for this process: users describe their design goals, the system converts them into structured tasks, and then generates or modifies the model through controlled design operations. The value of this shift lies not just in reducing manual operations, but in organizing scattered commands into goal-oriented workflows.

    However, it is necessary to distinguish between three levels:

    1. Generating seemingly reasonable modeling instructions.
    2. Generating executable operation sequences.
    3. Obtaining design results that meet engineering requirements.

    These three are not inherently equivalent. The model might correctly understand “add mounting holes” but miss the minimum distance requirement between the holes and the edges. A script might execute successfully but generate an unmachinable thin-walled structure. Therefore, LLMs are well-suited for intent understanding, task decomposition, and operation suggestions, while geometric computation, constraint solving, and engineering acceptance must still be handled by corresponding deterministic mechanisms.

    The core of intelligent design is not letting the model decide everything directly, but establishing a closed loop of “proposing solutions—controlled execution—result validation—correcting when necessary.”

    II. Translating Natural Language into Executable Design Intent

    1. Structure Requirements Before Generating Operations

    Natural language is often incomplete. For instance, “make the bracket thicker and add four holes to the bottom” does not specify the thickness increase, hole diameter, arrangement pattern, or which dimensions must remain unchanged.

    A reliable system should not guess blindly but should first extract the following information:

    • Operation objects: Parts, sketches, features, or assembly instances.
    • Modification targets: Dimensions, topological structures, material properties, or layouts.
    • Constraints: Fixed dimensions, symmetry relations, assembly fits, and non-editable zones.
    • Acceptance criteria: Number of holes, target thickness, interference status, and output requirements.
    • Missing information: Parameters and design basis requiring user confirmation.

    For key parameters affecting assembly, strength, or manufacturing, user confirmation should be required. For low-risk attributes like display color, default suggestions can be provided during the preview phase, but undo options must be available.

    2. Layered Processing of Geometry, Materials, and Scene Attributes

    Adjusting geometric structures, modifying material properties, and changing scene layouts belong to different task levels.
    Geometric modifications affect solid shapes and their topological relations; material modifications may affect mass calculations, analysis conditions, and manufacturing requirements; scene layouts may only change the display method or involve actual assembly positions. The system must distinguish these semantics to avoid mistaking display changes for engineering changes.

    For example, “change to a metallic texture” is usually just an appearance requirement and should not be automatically interpreted as specifying a real material. “Move the part to the right” also requires determining whether this means moving in the display scene or modifying assembly constraints. Only with clear semantics can subsequent execution be trustworthy.

    III. Adopting a Layered Architecture to Avoid Direct Model Control

    A general architecture that is easy to implement and govern can be divided into six layers.

    1. Interaction and Context Layer

    This layer receives text descriptions, selected objects, dimension annotations, and necessary image information. Rather than uploading complete design files, prioritizing the minimal context relevant to the current task helps protect sensitive data and reduces interference from irrelevant information during reasoning.
    Context should include units, coordinate systems, model versions, and current selection sets. Without this information, even a correct instruction might be applied to the wrong object.

    2. Intent Parsing and Task Planning Layer

    The model converts requests into structured plans, detailing the operation sequence, required parameters, expected impacts, and pending confirmations.
    The planning results should be independently inspectable rather than hidden in an unexplainable execution script. For high-impact operations like deleting features or altering assembly relations, the plan must explicitly list the risks.

    3. Design Action Abstraction Layer

    The system expresses design operations through a finite, explicit set of actions, such as creating sketches, setting constraints, generating solids, modifying dimensions, and checking interference.
    The action set must correspond to the capabilities of the actual design environment. Developers cannot assume that the underlying software supports a certain action just because the model generated it. Developers need to maintain action definitions, parameter rules, and version compatibility.

    4. Geometry and Constraint Execution Layer

    This layer calls upon existing geometric computation and constraint solving capabilities to actually modify the design data. The model should not replace the geometric kernel in determining whether surfaces intersect, nor should it deduce the legality of a solid based solely on language.

    5. Validation and Policy Layer

    The validation layer checks parameter legality, geometric validity, assembly relations, and business rules, while enforcing access control. Upon validation failure, it should return a clear reason rather than a generic “execution exception.”

    6. Version and Audit Layer

    Every modification should record the original request, structured plan, actual operations, check results, and final confirmer. This ensures that processes can be reproduced and designs restored to a known reliable state in case of issues.

    IV. Challenges in Local Modifications: Stable Positioning and Impact Control

    Compared to creating simple parts, modifying existing models is usually more complex. The position of a hole might relate to multiple sketch constraints, and a single dimension adjustment might invalidate subsequent features.

    1. Do Not Rely Solely on Temporary Face Numbers

    After a geometric model changes, the internal numbers of faces or edges might change. If the system only records “modify the nth face,” the next execution might select the wrong object.
    A more robust approach is to use a combination of feature origin, spatial position, geometric type, adjacency relations, and user selection information for positioning. If positioning results are ambiguous, the system should highlight candidate areas and request confirmation instead of continuing execution.

    2. Analyze Dependencies Before Modification

    Before local modification, direct and indirect impacts should be identified. For example, modifying the base plate thickness might simultaneously affect installation height, fastener length, and assembly clearance.
    The system can output an impact summary first: “This will modify the base plate thickness and may affect two mating relationships; the outer contour dimensions remain unchanged.” This type of feedback is more likely to gain the trust of engineers than directly submitting results.

    3. Use Transactions and Checkpoints

    A group of related operations should be executed as a rollable-back unit. If any critical step fails, it should revert to the valid state before modification, avoiding intermediate models that are partially successful and partially failed.
    For complex tasks, phased checkpoints can be set, but it must be clear which checkpoints have passed validation. Temporary results must not be mistaken for final deliverables.

    V. 2D, 3D, and Cloud Collaboration: Focus on Semantic Consistency

    2D drawings and 3D models carry different types of information. 2D expressions typically include dimensions, tolerances, technical requirements, and manufacturing instructions; 3D models provide spatial shapes, features, and assembly relations.
    Collaboration between the two cannot be simplified to “converting files to each other.”

    When deriving 3D from 2D, there may be missing views, incomplete dimensions, or non-unique structures. The system should annotate inferred parts and parts requiring confirmation, rather than packaging speculative results as the only correct answer.

    When generating 2D expressions from 3D, it is not enough to just project views; it also requires checking whether dimensions are complete, whether cross-sectional expressions are appropriate, and whether annotations comply with enterprise standards.

    The main value of cloud collaboration lies in unified task scheduling, version management, and cross-role review. For time-consuming modeling or validation tasks, tasks can be distributed via message queues, executed in isolated worker processes, and the results, logs, and preview files written to controlled storage.

    However, not all tasks are suitable for remote processing. For highly sensitive design data or strongly interactive operations, a combination of local execution and centralized management can be adopted. Deployment choices should be subordinate to data security, interaction latency, and O&M costs, rather than blindly pursuing cloudification.

    VI. Execution Loop Example: Separating Planning, Checking, and Committing

    The following is pseudo-code for the process, intended only to illustrate the division of responsibilities and does not correspond to any specific product interface:

    1. Receive design request
    2. Read current model version, units, and user selection
    3. Parse targets, constraints, and missing parameters
    4. If key parameters are missing:
    5. Request user to supplement
    6. Pause execution
    7. Generate structured operation plan
    8. Check permissions, allowed actions, and parameter ranges
    9. Display modification scope and potential impacts
    10. After user confirmation:
    11. Create isolated copy and recovery checkpoint
    12. Execute operation plan in the copy
    13. Check geometric validity
    14. Check target dimensions and constraints
    15. Check assembly relations and enterprise rules
    16. If all pass:
    17. Generate diff preview
    18. Commit new version after authorized confirmation
    19. Else:
    20. Discard copy or rollback
    21. Return failure reasons and optional correction suggestions

    This workflow emphasizes two principles: first, treating the model-generated plan as input to be verified; second, providing preview and confirmation opportunities before formal design data is altered.

    For low-risk, highly repetitive tasks, manual confirmation steps can be reduced under strict rules. For changes involving critical structures, materials, or manufacturing requirements, professional approval should be retained.

    VII. Layered Engineering Validation: Beyond “Script Execution Success”

    1. Parameter and Unit Checks

    First, check whether inputs are complete, whether values are within allowed ranges, and whether units are consistent. Confusion of units for length, angles, and material parameters often leads to severe deviations.

    2. Geometric Validity Checks

    Check whether solids are valid, and whether self-intersections, zero-thickness, abnormally small faces, or other geometric issues occur. Specific check capabilities depend on the underlying geometric environment, and acceptance items should be set based on actual capabilities.

    3. Constraint and Assembly Checks

    Confirm whether sketches contain conflicting constraints, whether critical dimensions are maintained, and whether unauthorized interference occurs in assemblies. Note that interference fits may be intentionally set in designs, so “detecting intersection” cannot be uniformly judged as an error.

    4. Engineering and Manufacturing Checks

    Perform rule checks on minimum wall thickness, hole edge distance, machining accessibility, and material requirements. Such rules must have a clear scope of application; specific process experience cannot be generalized as a universal standard for all designs.

    Conclusions regarding structural safety, lifespan, or thermal performance require corresponding analysis conditions and professional validation, and cannot be drawn solely based on model appearance or language explanations.

    VIII. Data Governance and Security Control: Keys to Production Readiness

    Industrial design data may contain unpublished structures, process expertise, and supply chain information. Intelligent design systems need to implement the principles of least privilege and data minimization, clarifying what content can enter the model context, how long it is saved, and who can view it.

    Comments and external texts within design files should also be treated as untrusted inputs. They can serve as reference materials but cannot override execution policies, let alone grant permissions autonomously.

    If script generation is allowed, file access, network access, and process invocation capabilities should be restricted, with limits set on execution duration, resource usage, and operation counts. Generated scripts must not directly enter production environments with broad permissions.

    Enterprise historical data is not necessarily better in larger quantities. Duplicate models, outdated specifications, and incorrect annotations can amplify system bias. Priority should be given to building a curated knowledge collection with version and scope descriptions, allowing the model to retrieve correct rules rather than indiscriminately absorbing all materials.

    IX. Evaluating ROI and Implementation Priorities

    When evaluating an intelligent design system, one should not only look at demo effects or single-generation speed, but at end-to-end delivery quality.

    It is recommended to continuously track the following metrics:

    • Task completion rate: The proportion of results that truly meet acceptance criteria under limited conditions.
    • First-time acceptance pass rate: The proportion of results acceptable without rework.
    • Manual correction cost: Time required for users to adjust parameters, repair models, and handle exceptions.
    • Change traceability: The ability to completely reconstruct the reasons for operations and the execution process.
    • Total cost per task: Including reasoning, computation, review, and maintenance overhead.
    • Cross-version stability: Whether original tasks can continue to execute reliably after design environment upgrades.

    During implementation, prioritize scenarios with clear boundaries, high repetition frequency, and easily verifiable results, such as parametric part variant design, batch attribute organization, drawing check assistance, and standardized operation orchestration.

    For open-ended complex designs, providing solution suggestions and operation drafts first is preferable to rushing for fully automated delivery. The scope of automated execution should only be expanded as data, rules, validation, and rollback capabilities mature.

    Conclusion

    CAD connects digital representation with physical manufacturing, and LLMs are expected to lower the barriers to intent expression and operation orchestration. However, moving from a single requirement to a reliable part still requires the joint support of geometric computation, constraint management, engineering rules, and professional review.

    Truly deployable intelligent design does not mean letting models bypass traditional engineering systems, but rather letting them play a role within clear permission and validation boundaries. Only by using structured intent as the entry point, deterministic execution as the foundation, and engineering validation as the closed loop can generative capabilities be transformed into stable, maintainable production capacity.