SOLIDWORKS AI macro generation is changing how engineers can approach repetitive CAD automation tasks in 2026.
Instead of starting every automation idea with an empty VBA editor, engineers can now describe certain tasks to LEO, the SOLIDWORKS AI Virtual Companion, and ask it to generate a custom macro. The generated VBA code can then be opened in the editor, reviewed, modified, executed, and refined through further instructions.
That sounds simple, but the engineering impact is much bigger than faster code creation.
For CAD teams, SOLIDWORKS AI macro generation introduces a new starting point for automation: begin with engineering intent, generate an implementation, review what the system created, test it, and decide whether the result is reliable enough for the intended workflow.
The opportunity is significant.
So are the responsibilities.
AI-generated code does not remove the need to understand SOLIDWORKS, the API, file relationships, configurations, drawings, output requirements, or engineering validation.
This guide explains what the capability actually does, where it can help, its current limitations, and how engineers can use it within a practical validation-first CAD automation workflow.
What Is SOLIDWORKS AI Macro Generation?
SOLIDWORKS AI macro generation is a workflow automation capability associated with LEO, one of the SOLIDWORKS AI Virtual Companions.
In the SOLIDWORKS Design R2026x FD03 update, SOLIDWORKS introduced the ability to describe repetitive tasks to LEO and have the system create a custom SOLIDWORKS macro.
SOLIDWORKS officially highlights tasks such as:
- Renaming files
- Exporting deliverables
- Applying company standards
- Updating model properties
- Automating repeatable CAD operations
The generated macro is opened in the VBA editor so the user can inspect it before or during execution. Engineers can also continue the conversation with LEO to refine the macro when additional requirements are needed.
This distinction is important.
LEO is not simply returning a block of generic programming advice in an external chatbot.
It is working within the SOLIDWORKS environment and can create VBA automation intended to operate on SOLIDWORKS data.
That brings AI much closer to executable engineering workflows.
What changes compared with traditional macro development?
Traditionally, a simple SOLIDWORKS macro often starts like this:
Requirement → API research → VBA coding → Debugging → Testing → Execution
With SOLIDWORKS AI macro generation, the initial path can become:
Requirement → Natural-language instruction → Generated VBA → Engineer review → Testing → Execution
The API has not disappeared.
The starting point has changed.
How SOLIDWORKS AI Macro Generation Works
The official Dassault Systèmes workflow provides a useful picture of how the process works.
1. Describe the automation task
The engineer opens the Virtual Companions tab in SOLIDWORKS Design and selects LEO.
A requirement can then be entered in natural language.
For example:
Generate a macro to export every part file in the active assembly as a STEP file.
This is much closer to describing engineering intent than manually searching for every API method required to implement the task.
2. LEO creates the VBA macro
LEO processes the request and generates the macro.
When generation finishes, the VBA editor opens and displays the code.
This is an important point for engineering control: the code is visible.
It can be inspected.
It can be changed.
It is not simply an invisible automation action running behind the interface.
3. The engineer reviews the implementation
Before using generated automation on important data, an engineer should inspect questions such as:
- What document type does the macro expect?
- Does it check whether a document is open?
- Which configuration is being processed?
- Does it process suppressed components?
- How are filenames generated?
- Where are exported files stored?
- Can existing files be overwritten?
- What happens if a file fails?
- Are return values being checked?
- Can the macro modify source files?
- Does the logic match the original engineering requirement?
This review stage is where CAD knowledge remains critical.
4. Run or refine the macro
The macro can be executed from the VBA environment.
If the first implementation does not completely match the requirement, the user can continue interacting with LEO and ask for modifications.
This makes SOLIDWORKS AI macro generation iterative rather than strictly one-shot.
The workflow becomes:
Describe → Generate → Review → Run → Evaluate → Refine
Official SOLIDWORKS AI Macro Generation Use Cases
Dassault Systèmes has published several example prompts demonstrating the types of workflow that can be attempted.
Examples include:
- Export every part in an active assembly as STEP
- Export a sheet-metal flat pattern as DXF
- Create a 3D sketch from point information stored in CSV
- Export all sheets in an active drawing to one PDF
- Save open documents as PDFs in their existing directories
- Export drawings from a folder as DXF files
- Set drawing-view scale to the sheet scale
- Rename drawing sheets based on referenced model names
- Close all open documents except drawings
- Save virtual components from an active assembly as individual files
These examples are useful because they show that SOLIDWORKS AI macro generation is aimed at practical CAD productivity rather than simple demonstration scripts.
They also reveal where the technology is likely to provide immediate value.
Good early candidates include repetitive tasks that are:
- Clearly defined
- Rule-based
- Repeated frequently
- Easy to verify
- Limited in scope
- Based on existing SOLIDWORKS functionality
- Suitable for macro-level automation
- Able to produce measurable output
Export automation is a strong example because an engineer can verify filenames, formats, file counts, folder locations and failed exports.
That makes the outcome observable.
7 Powerful Benefits of SOLIDWORKS AI Macro Generation
1. Faster automation prototyping
One of the biggest benefits of SOLIDWORKS AI macro generation is reducing the distance between an automation idea and a working prototype.
An engineer may identify a repetitive workflow during normal design work.
Previously, implementing it could require:
- Finding the relevant SOLIDWORKS API objects
- Searching documentation
- Studying examples
- Writing VBA
- Correcting syntax
- Debugging selections
- Testing the macro
- Repeating the cycle
AI assistance can shorten the early coding stage.
That means engineers can evaluate automation ideas faster before investing in a larger application.
2. Lower entry barrier for SOLIDWORKS automation
Many mechanical engineers understand exactly what should be automated but do not use the SOLIDWORKS API regularly.
The knowledge gap may be programming rather than engineering.
SOLIDWORKS AI macro generation can help such users move from:
“I repeat this process every day”
to:
“Can this process become an automated workflow?”
This is particularly useful for design engineers, manufacturing engineers, CAD administrators and application engineers who understand the task but are not full-time software developers.
3. Faster creation of repetitive export workflows
Exports are common automation candidates.
Typical workflows include:
- PDF generation
- STEP export
- DXF creation
- Flat-pattern export
- Batch drawing processing
- File conversion
- Drawing-sheet processing
- Packaging deliverables
These activities are repetitive, measurable and often governed by straightforward rules.
That makes them good candidates for controlled SOLIDWORKS AI macro generation experiments.
4. Easier iterative requirement development
Real automation requirements rarely arrive perfectly defined.
A user may initially request:
“Export all parts as STEP.”
After testing, the actual requirement may become:
- Exclude suppressed components
- Ignore standard hardware
- Use configuration-specific filenames
- Create a new output folder
- Skip duplicate components
- Record failed exports
- Prevent overwriting
- Generate a summary report
Conversational refinement can help expose these hidden requirements earlier.
The value is not only code generation.
It is requirement discovery.
5. More time for engineering logic
If AI handles part of the repetitive coding work, automation engineers can spend more time designing the workflow itself.
That includes:
- Input validation
- Exception handling
- Engineering rules
- Configuration logic
- Drawing checks
- Metadata checks
- Release conditions
- Error reporting
- Audit trails
- User permissions
- Testing strategy
- Output verification
This is where mature engineering automation creates value.
6. Better bridge between domain experts and developers
Production automation often involves two different forms of expertise.
The domain engineer understands:
- CAD structure
- Design intent
- Manufacturing rules
- Drawings
- BOM behaviour
- Configurations
- Revision requirements
The developer understands:
- API architecture
- Programming
- Interfaces
- Databases
- Error handling
- Deployment
SOLIDWORKS AI macro generation can provide an additional bridge between these groups by helping engineering requirements become executable prototypes faster.
It does not replace either discipline.
It can improve communication between them.
7. A practical path toward broader engineering automation
A successful generated macro can also reveal whether a workflow deserves further investment.
A small prototype may later evolve into:
- A controlled VBA utility
- A C# application
- A SOLIDWORKS add-in
- A batch-processing service
- A PDM-connected tool
- A validation dashboard
- A release-control application
- A larger CAD automation platform
The macro can therefore become a discovery tool.
Not every prototype should become production software, but valuable automation opportunities can be identified much faster.
Why SOLIDWORKS API Knowledge Still Matters
The arrival of SOLIDWORKS AI macro generation does not make the SOLIDWORKS API obsolete.
The opposite may happen.
More generated automation means more code that engineers need to understand, review and validate.
SOLIDWORKS describes its API as a COM programming interface providing direct access to SOLIDWORKS functionality. The API contains hundreds of functions accessible from VBA, VB.NET, C++, C# and other supported environments.
Traditional macros also remain fully relevant.
SOLIDWORKS documentation identifies macro recording as one of the fastest ways to begin learning the API and explains how recorded macros can be edited in VBA or VSTA.
An engineer reviewing generated code should still recognize concepts such as:
ISldWorksModelDoc2PartDocAssemblyDocDrawingDocComponent2FeatureSelectionMgrCustomPropertyManager- Configuration handling
- Document types
- Selection logic
- Save and export methods
- Rebuild behaviour
For a deeper foundation, The Tech Thinker’s SOLIDWORKS API Cheat Sheet 2026 explains these objects and their role in real automation workflows.
The better you understand the API, the better you can judge whether AI-generated automation is trustworthy.
SOLIDWORKS AI Macro Generation Needs a Validation-First Workflow
This is where we need to distinguish between an official SOLIDWORKS capability and an engineering methodology.
LEO generating the macro is an official capability.
The following validation-first process is an engineering recommendation for using generated automation responsibly.
A practical six-stage workflow
1. Define
Clearly describe:
- Input files
- Required document types
- Expected outputs
- Folder locations
- Naming rules
- Configurations
- Exclusions
- Failure behaviour
2. Generate
Use LEO or another approved development method to create the initial automation.
3. Review
Inspect:
- API calls
- Selection logic
- File operations
- Hard-coded values
- Error handling
- Assumptions
- Loops
- Save operations
- Output naming
4. Test
Use representative copies rather than the only available production files.
Test:
- Parts
- Assemblies
- Drawings
- Multiple configurations
- Missing references
- Empty selections
- Read-only data
- Existing output files
- Invalid paths
- Unexpected document types
5. Verify
Compare expected and actual results.
Verification can include:
- Expected file count
- Actual file count
- Correct filenames
- Correct extension
- Correct configuration
- Correct drawing sheets
- Correct properties
- Successful rebuild state
- Failed-item log
- Processing summary
6. Approve and run
Only after the workflow behaves predictably should it be considered for controlled production use.
This is the principle behind validation-first CAD automation:
Generation should not automatically equal permission to execute.
For a broader engineering checklist, The Tech Thinker’s CAD Validation Checklist covers geometry, references, drawings, BOMs, metadata, configurations and manufacturing readiness.
Risks and Limitations Engineers Should Understand
AI-assisted automation is useful, but it should not be presented as unlimited.
Dassault Systèmes itself notes that some requested changes may not be possible because of the capabilities or limitations of macro tools.
Engineers should therefore watch for several risks.
1. Ambiguous requirements
“Export my drawings” may have ten different meanings inside different companies.
AI cannot reliably infer every undocumented business rule.
2. Correct code can still implement the wrong rule
A macro may compile perfectly and still produce the wrong engineering result.
3. File operations can have consequences
Batch rename, overwrite, delete, save and property-editing operations should be treated carefully.
4. CAD context matters
Parts, assemblies and drawings have different object models and workflow behaviour.
5. Configuration handling can change outputs
A model may contain multiple configurations with different geometry or metadata.
6. Referenced data may be incomplete
Missing components or drawing references can make an otherwise valid macro produce incomplete output.
7. Production requirements are more complex than demos
Enterprise workflows may require:
- Authentication
- Permissions
- PDM integration
- Revision checks
- Audit logs
- Database access
- Transaction control
- Rollback
- Deployment management
8. Generated code still requires maintenance
Automation must survive:
- New SOLIDWORKS releases
- API changes
- Company-standard changes
- Folder changes
- Naming changes
- New configurations
- User behaviour
- New failure cases
That is why SOLIDWORKS AI macro generation should be viewed as an accelerator, not an automatic certification system.
SOLIDWORKS AI Macro Generation Requirements and Availability
Availability is another area where accuracy matters.
The current Dassault Systèmes guidance states that SOLIDWORKS AI Virtual Companions can be accessed inside SOLIDWORKS Design through the Virtual Companions area.
For use within SOLIDWORKS Design, the current guidance specifies:
- SOLIDWORKS Design 2026 SP3.2 or later
- Connection to the 3DEXPERIENCE platform
- An applicable SOLIDWORKS Design entitlement
- Additional setup depending on named-user or device-locked licensing
- Collaborative Designer for SOLIDWORKS role where applicable
- Design with SOLIDWORKS installation where required
Dassault also states that users do not have to save their SOLIDWORKS files to the 3DEXPERIENCE platform merely to use AURA or LEO.
SOLIDWORKS states that commercial SOLIDWORKS Design Offer and SOLIDWORKS Design with Cloud Services customers can access AURA and LEO without an additional companion licence, while AI usage follows a token-based consumption model.
Because licensing and availability can evolve, organisations should confirm their own current entitlement and installation requirements before planning deployment.
| Area | Traditional approach | AI-assisted approach |
| Starting point | API knowledge/code | Natural-language requirement |
| Initial coding | Manual | AI-generated draft |
| VBA knowledge | Usually needed early | Less necessary for initial prototype |
| Review | Developer review | Engineer/developer review still needed |
| Testing | Required | Required |
| Debugging | Manual | Manual + conversational refinement |
| API understanding | Important | Still important |
| Validation | Required | Required |
| Production governance | Required | Required |
| Complex integrations | Custom development | Usually still custom development |
The key difference is therefore not that engineering knowledge disappears.
SOLIDWORKS AI macro generation shifts more of the early implementation work toward AI assistance.
The responsibility for engineering correctness remains with the people deploying the workflow.
Best Practices for SOLIDWORKS AI Macro Generation
Teams exploring this capability should establish simple rules from the beginning.
Recommended practices include:
- Start with low-risk workflows.
- Define the expected result before generating code.
- Use copied or test data first.
- Review generated VBA before production use.
- Confirm document type explicitly.
- Check whether an active document exists.
- Validate file and folder paths.
- Avoid silent overwriting.
- Log failed operations.
- Report processed and skipped files.
- Verify expected versus actual output counts.
- Check configurations explicitly.
- Handle suppressed components intentionally.
- Avoid unnecessary rebuilds.
- Add error handling around critical API calls.
- Separate company rules from hard-coded logic where possible.
- Keep a version history for approved macros.
- Document what each macro is permitted to modify.
- Re-test automation after major software updates.
- Keep human approval for high-impact batch operations.
These practices apply regardless of whether the first line of code was typed by a developer, recorded by SOLIDWORKS, or created through SOLIDWORKS AI macro generation.
When a Macro Is No Longer Enough
One of the most important engineering decisions is knowing when not to keep expanding a macro.
A macro is generally suitable when the workflow is:
- Local
- Well-defined
- Limited in scope
- User initiated
- Easy to verify
- Based mainly on SOLIDWORKS operations
A more structured application may be appropriate when the workflow requires:
- Complex user interfaces
- Persistent configuration
- Database connectivity
- PDM/PLM integration
- Multi-user deployment
- Background services
- Enterprise authentication
- Large-scale batch processing
- Detailed logging
- Role-based permissions
- Long-term maintainability
- External REST APIs
- ERP/MES integration
This is where the broader CAD Automation Ecosystem becomes important.
Modern CAD automation is not only about macros. It can include APIs, add-ins, validation engines, databases, PDM/PLM systems, reporting tools and AI-assisted workflows.
The Tech Thinker’s CAD Automation Ecosystem guide explores that larger architecture.
How SOLIDWORKS AI Changes the CAD Automation Engineer’s Role
The most interesting impact of SOLIDWORKS AI macro generation may not be the macro itself.
It may be how the role of the automation engineer evolves.
When routine code becomes easier to generate, value moves toward areas that are harder to automate blindly.
Future CAD automation skills will increasingly include:
- Engineering requirement definition
- SOLIDWORKS API architecture
- Workflow decomposition
- Validation design
- Exception handling
- Engineering data governance
- PDM/PLM integration
- Configuration management
- Test-case development
- Auditability
- Deployment strategy
- Human approval design
- AI-assisted development
- System-level thinking
The engineer is moving from simply asking:
“How do I code this task?”
toward:
“How should this engineering workflow behave, how should it fail safely, and how can its result be independently verified?”
That is a much more valuable question.
Where SOLIDWORKS AI Is Heading Beyond Macro Generation
Macro generation is only one element of SOLIDWORKS’ wider AI direction.
The R2026x FD03 announcement also describes LEO capabilities for:
- Assembly performance analysis
- Large-assembly optimisation guidance
- Part and assembly simplification
- SpeedPak recommendations and creation
- Assembly instruction generation
- Engineering selection assistance
- Workflow automation
For assembly performance, for example, LEO can evaluate areas including opening time, rebuild time, graphics load and structural complexity and then return prioritised recommendations.
Dassault has also positioned LEO as an engineering-focused AI companion operating inside the design environment rather than as a generic external chatbot.
This suggests a broader direction:
AI is moving from advising engineers about CAD toward participating directly in controlled CAD workflows.
That makes validation, traceability and human authority increasingly important.
Final Thoughts
SOLIDWORKS AI macro generation represents an important change in the accessibility of CAD automation.
An engineer can now begin certain workflows by describing the intended task rather than immediately searching API documentation and manually constructing every line of VBA.
That can accelerate prototypes.
It can make automation accessible to more engineers.
It can reduce repetitive coding.
It can help teams discover automation opportunities faster.
But the real engineering challenge remains unchanged.
The result must be correct.
A macro should not be trusted simply because it runs without displaying an error.
A reliable automation workflow should make its assumptions clear, handle expected failures, protect source information, produce reviewable outputs and provide enough evidence for an engineer to determine whether the result is acceptable.
That is why the future of SOLIDWORKS AI macro generation is not simply:
Prompt → Code → Run
A more mature engineering model is:
Intent → Generate → Review → Test → Validate → Approve → Execute → Verify
AI can accelerate macro creation.
Engineers remain accountable for the workflow and the engineering result.
FAQs About SOLIDWORKS AI Macro Generation
What is SOLIDWORKS AI macro generation?
SOLIDWORKS AI macro generation is a capability that allows engineers to describe certain automation tasks to LEO, the SOLIDWORKS AI Virtual Companion, which can generate a VBA macro for review and execution in SOLIDWORKS Design.
Can LEO generate SOLIDWORKS VBA macros?
Yes. Current Dassault Systèmes documentation shows LEO generating VBA macros from natural-language prompts and opening the generated code in the VBA editor.
Does SOLIDWORKS AI macro generation replace SOLIDWORKS API knowledge?
No. AI can reduce the initial coding effort, but SOLIDWORKS API knowledge remains valuable for reviewing generated code, troubleshooting problems, handling complex requirements and building production-grade automation.
What kinds of macros can SOLIDWORKS AI generate?
Official examples include STEP export, DXF flat-pattern export, PDF generation, drawing-sheet renaming, CSV-driven 3D sketch creation, drawing-scale changes and saving virtual components.
Should AI-generated macros be used directly on production CAD files?
For low-risk personal workflows, engineers may choose their own level of control. For production or controlled engineering data, the safer approach is to review the code, test it on representative copies, verify the outputs and approve the workflow before wider use.
Is SOLIDWORKS AI macro generation available in every SOLIDWORKS installation?
No assumption should be made that every installation has identical access. Current guidance specifies SOLIDWORKS Design 2026 SP3.2 or later for the Virtual Companions inside SOLIDWORKS Design, along with a 3DEXPERIENCE connection and applicable setup or entitlement.
Do SOLIDWORKS files need to be stored on 3DEXPERIENCE to use LEO?
According to current Dassault Systèmes guidance, users do not need to store their files on the 3DEXPERIENCE platform simply to use AURA or LEO.
Is an AI-generated macro production-ready automatically?
No. Generated code should be treated as an implementation that still requires engineering review, testing and verification according to the risk and importance of the workflow.
Who is Ramu Gopal, and how does his work relate to SOLIDWORKS AI LEO automation?
Ramu Gopal is a CAD automation and AI systems professional who focuses on practical engineering automation, SOLIDWORKS API workflows, validation-first systems, and AI-assisted engineering processes. His work explores how tools such as SOLIDWORKS AI LEO can accelerate macro creation while engineers remain responsible for workflow design, API understanding, testing, validation, and production reliability.
How does Ramu Gopal recommend using SOLIDWORKS AI LEO for automation?
Ramu Gopal recommends using SOLIDWORKS AI LEO automation as an accelerator rather than a replacement for engineering judgment. A practical approach is to define the task clearly, let LEO generate the macro, review the VBA and API logic, test it on controlled data, verify the outputs, and only then approve it for production use. This validation-first approach helps combine faster AI-assisted automation with safer and more reliable engineering outcomes.
Author: Ramu Gopal
CAD Automation | AI Systems
The Tech Thinker
This article provides independent engineering analysis of publicly documented SOLIDWORKS capabilities. The validation-first methodology discussed here is an engineering recommendation and should not be interpreted as an official Dassault Systèmes or SOLIDWORKS product feature.
External References:
SOLIDWORKS R2026x FD03 AI announcement
