Show HN: AI in SolidWorks

For AI designed schematics, you need to check out flux.ai (and quilter for layout), I don't have anything to do with this, i'm a little jealous tbh, but having used it, it's not for me (but i'm making fairly complex, FuSa, type approved stuff, for the sorts of boards that would go into phaestus, it would probably be adequate)

I'm pretty in the weeds when it comes to this stuff,

First of all, I made https://www.circuitsnips.com/ , which is like thingiverse for circuits, so users can get bits of designs and copy and paste them into their own designs, but the reception was lukewarm at best, it needed bootstrap data, for which I scraped GH, which could have been a mistake, either way, for the tens of people using it, I think it's pretty neat!

Circuitsnips Blog:https://www.mikeayles.com/#circuitsnips-com Circuitsnips GH:https://github.com/MichaelAyles/kicad-library

So, then I created a fork of TOON, called TOKN, which is token optimised KiCad notation, which successfully compresses kicad schematic s-expressions by 93%, and is able to regenerate schematics from it. With the intention of trying to generate schematics, one shot them using frontier models, or even post-train an OSS model to see if that works, however when I benchmarked it, I could get 100% syntax validity, but the models hallucinated the components, the pins etc, so they would need grounding.

TOKN Blog:https://www.mikeayles.com/#tokn TOKN GH:https://github.com/MichaelAyles/tokn

Which brings me onto my next, next, (next?) side project: An embedded documentation MCP server!, Load in your PDF's, it parses them and puts things into a sqlite db that the LLM can interact with more efficiently. I mainly use it for writing hardware abstraction layers for chips that have terrible vendor support (looking at you, NXP KEA128). Honestly, everything about this chip is awful, even the GPIO is laid out terribly, it's like the meme where everything gets put in the square hole. PORTB? nah, you need to do PORTA + 16. Anyway...

Bitwise-MCP Blog:https://www.mikeayles.com/#bitwise-mcp Bitwise-MCP GH:https://github.com/MichaelAyles/bitwise-mcp

And if you've read this far, here's a little treat:

https://www.mikeayles.com/#kidoom-featured

Yep, exactly. I'll do another blog when I have a little more to show, but the concept is, everything is on a grid of 12.7mm squares, where there is a common bus running through north-south. The boards need to be 4 layer and feature size is pretty small, 0402 passives for example, maybe even 0201 if I'm really optimising for size.

SCH: https://github.com/MichaelAyles/heph/blob/main/blogs/0029-im...

3D bottomside: https://github.com/MichaelAyles/heph/blob/main/blogs/0029-im...

In the Phaestus workflow, it chooses modules, for example the main cpu block just has an ESP32C6-XIAO board on it, since it has massive compute, and radio with wifi6 and zigbee, which covers 90% of IOT. Since this is larger than 0.5" it sits in the middle of a 2x2, which bridges both sets of north-south buses, with all common pins.

Bidged pinouts: https://github.com/MichaelAyles/heph/blob/main/blogs/0029-im...

Early XIAO: https://github.com/MichaelAyles/heph/blob/main/blogs/0029-im...

It's been a pain in the butt to design for, since the vias need enough clearance, and we are almost maxed out on our bottom side, so on the 2x2's i've given it as much room as I can in the middle to allow for topside routing with a few vias.

Then, when assembling the board, it does a 0.1mm overlap n/s, which merges the nets, whilst the system keeps track of what signals are used, so I2C is all multiparticipant, spi1 gets the default CS line, otherwise it can use the aux pins via a resistor selector, the AUX5/AUX6 aren't connected to the XIAO, so if you wanted to do something like a USB power monitor, the power can run isolated at higher voltages, as long as they get fed through a current/voltage sensing block, which could be 1x1, 1x2 or 2x2.

As for component placing in the enclosure, buttons are sub-boards with a wire-to-board connector, and the 1x1 module is a block that contains a connector and an PCA9570, which allows the button to be placed anywhere with defined mounting features.

Similar for LCD's, the pre-designed block has a FFC connector, and comes with constraints, e.g. place at end of design, so the screen can fold back on itself, whereas if it was mounted in the middle, it wouldn't be able to go where it needs to be.

We had a sales person try to explain how file handling in 3DExperience is done. They were presenting how magic everything is where the right version of the file is always present in Catia for modelling, Abaqus for FEA, and whereever else in the package.

OK, how do we work with our CMM and CAM software? How do we send files to clients and vendors? crickets

Not confidence inspiring.

I don't get the text obsession beyond LLMs being immensely useful that you might as well use LLM for <insert tasks here>. I believe that some things live in text, some in variable size n-dimensional array, or in fixed set of parameters, and so on - I mean, our brains don't run on text alone.

But, you need the ambiguity, or the AI isn't really a help. If you know the exact coordinates and dimensions of everything, you've already got an answer.

When I use Claude to model I actually just speak to it in common English and it translates the concepts. For example, I might say something like this:

    I'm building a mount for our baby monitor that I can attach to the side of the changing table. The pins are x mm in diameter and are y mm apart. [Image #1] of the mounting pins. So what needs to happen is that the pin head has to be large, and the body of the pin needs to be narrow. Also, add a little bit of a flare to the bottom and top so they don't just knocked off the rest of the mount.

    We need a bit of slop in the measurements there because it's too tight.

Amusingly, I did this just a couple of weeks ago and that's how I learned what a chamfer is: a flat angled transition. The adjustment I needed to make to my pins where they are flared (but at a constant angle) is a chamfer. Claude told me this as it edited the OpenSCAD file. And I can just ask it in-line for advice and so on.

I think that would make a lot of sense for non-CAD images, but the particular task you described there is do-able in just a few clicks in most CAD systems already. I think the AI would almost always take a longer time to do those kinds of actions than if you did it yourself.

Solidworks's current controls are the best interface for it. "Draw a picture" is something you're going to find really difficult to beat. Most of the other parametric CADs work the same way, and Solidworks is widely known as one of the best interfaces on top of that. They've spent decades building one that is both unambiguous and fast.

maybe some combination of visual representation with text. For example it's not easy to come up intuitive with names of operations which could be applied to some surface. But if you could say something like 'select top side of cylinder' and it will show you some possible names of operations (with illustrations/animations) which could be applied to it then it's easy to say back what it need to do without actually knowing what actually possible. So as result it maybe just much quicker way to interact with CAD that we are using currently.

The clear alternative is VR. You put on hand trackers and then physical describe the part to the machine. It should be rid m this wide, gestures, and moves hands that wide.

https://shapelabvr.com/

I designed some parts for an enclosure over the weekend using claude opus to generate an OpenSCAD file, which I then exported to STL and sent to a 3D printer. I was able to get a visually-correct-enough STL off to the 3D printer in about 5 minutes.

I then waited about an hour for the print to finish, only to discover I wanted to make some adjustments. While I was able to iterate a couple times, I quickly realized that there were certain structures that were difficult to describe precisely enough without serious time spent on wording and deciding what to specify. It got harder as the complexity of the object grew, since one constraint affects another.

In the end, I switched to FreeCAD and did it by hand.

Will echo sibling. I have tried using Claude Sonnet for OpenSCAD to design a simple soap mold and it failed terribly in getting the rounded shape I wanted. (1) It's really difficult to explain 3d figures in text, and I doubt there is a lot of training material out there. (2) OpenSCAD is limited in what it can do. So the combination is pretty bad.

I needed some gears generated recently, and figured I could just get it done with Claude or Chatgpt in OpenSCAD in a few minutes... but oh man was I wrong. I was so wrong.

Wasted half an hour generating absolute nonsense if it even compiled and ended up going with one of those svg gear generators instead lmao.

> If you're getting Opus or anything else to interact with SolidWorks from the CLI, can you say more about how you're getting it to interface effectively?

I just have a Solidworks plugin that translates CLI calls to JSON to Solidworks API calls and back again.

What really started working was creating a bunch of high level CLI commands so that Claude Code could query the part/assembly by asking stuff like "What is the closest distance between the southmost surface of Extrusion1 and the surface of Cylinder2" which would then be translated to a specific high level command or a bunch of lower level commands by Gemini 3 Flash. Those would then be translated to Solidworks API calls, as would any editing commands. It also really helps to give it the ability to parametrize the queries so instead of "all features smaller than 2mm" it can say "all features smaller than $MinFeatureSize", with some logic and a downstream LLM to translate that parameter into values in the design and review it with the human in the loop before committing it to the project.

The key is to absolutely minimize how often the LLMs think about numbers and have them think in relationships instead. The hard part is translating those relationships back to the CAD API calls but LLMs are much better at hot hallucinating if you resolve all the parametrized equations last.

> How did you make Claude "know" the PCB layout/schematic specifics? Is just giving it a "reference prompt" enough to produce any interesting results?

I have a mini query language in the CLI that implements a lot of spatial queries, both structured and via prompts (another LLM translates the prompt to a structured query), against the Altium file format and an intermediate representation I keep. Most queries and editing commands use relative positioning ("to the left of"), units ("right edge minus 10mm"), and parameters (U1.P1.Top + MinSpacing * 5), etc. The LLM rarely needs to use concrete units because it's mostly parametrized by component clearances and design rules - I just choose some numbers at the beginning like board size and layer stackup (mostly set by the fab).

The CLI has over a hundred subcommands and I use Claude skills to split up the documentation, but the agent actively explores the schematic and PCB themselves. The Claude skills include instructions to use the measurement subcommands to sanity check after making a move or when doing a review at the end, although I'm in the process of implementing a GPU based design rule checker. My Solidworks interface works the same but there are many more "verbs" there for the LLM to manage.

At the end of the day it's mostly just orchestrating another tool which does most of the spatial logic and calculations. It's definitely easier with Altium than Solidworks so far.

> Very interested in your workflow - do you have anything online to share?

Not yet but once I'm ready it's all going to be open source.

> Also looked into automating altium more and found having to do a lot of GUI work to guide the models along.

Have you tried the Windows UI Automation/Accessibility APIs? You can download Accessibility Insights for Windows to see the data structure and it's well supported by Altium. It has everything you need to tell the LLM what's on screen without ever sending a screenshot (except for the 2d/3d CAD view) and the UIA provides an API that can actually click, focus, etc. without sending fake keyboard events manually. When reverse engineering the file format I put Opus on a loop and it just kept fiddling with the binary file format until Altium stopped throwing parsing errors.

> How much of going from ‘design in head’ to schematic and layout have you automated?

At this point everything but the final PCB routing. My autorouter and autoplacer are very much a work in progress and LLMs aren't great at routing complex traces, but they can brute force it given enough time and DRC checks. Right now I just shell out to autorouters like Specctra with a DSN and route the most important nets by hand in Altium. Since the LLM sets up all the design rules and can spend hours on a loop figuring out the optimal placement, it's usually a breeze. Especially compared to when I first started out in EE and spent days with part selection and footprint capture. Now a lot of that tedium is completely automated.

Soon I'll integrating probe-rs into the whole workflow and making end to end vibe PCBs, adding support for FPGAs, and integrating Solidworks so it does enclosures and molds too.

The people who use Solidworks buy Solidworks to use Solidworks. You'll go up to one of them and they'll have the whole model done in like 8 key presses before you even finish typing in your prompt.

All the people who aren't professional CAD users have Fusion, which they can get for free. They would probably benefit the most from text to model AI, but would probably also be the least willing to pay.

My experience has been professional engineers are using Solid works. Hobbiests are using a variety of often free software.

Seemingly half the FDM modellers on Printables.com use Fusion 360

Solidworks is the GOAT though

Not sure if it's a "flaw" or not, but I always get stuck on AI + 3D design stuff with there being no dimensional information or control.

How big is that mug? Slowing it down and trying to catch some dim info the initial cylinder has a radius of ~39. Regardless of if that's default inches, that's one hell of a mug.

Sure you can scale it, but it's not great practice to design something and then just apply a scaling to get it to the intended size.