Atoms Don't Compile

In a repo on my laptop there is a STEP file for a part that does not exist.

The part is a clamp adapter – it wraps around a bike handlebar and holds a phone mount. Six numbers describe the entire geometry. A Python script, written mostly by an agent, turns those numbers into the file. Regenerating it for a different handlebar takes seconds.

The file has been sitting in the repo since spring. The physical part has never been made.

That gap – between how fast an agent can describe a thing and how slow the world is to produce it – is the most consequential unsolved problem in physical product development right now. It has a name, though almost nobody uses it yet. Call it the compiler problem.

Agentic coding has changed software development faster than I expected. Not gradually. The Anthropic 2026 Agentic Coding Trends Report puts the number plainly: teams using coding agents are shipping four to six times as much code per week as before. Engineers personally type eighty percent less. The output volume is higher. The reason is not that the AI is smarter than the engineer.

The reason is the feedback loop.

Write a line of code. Run it. See the error. Fix the error. Repeat. The entire cycle happens in under a second. When you hand that loop to an agent, the agent can spin it a hundred times while you make coffee. The compounding effect of a tight feedback loop running at machine speed is what produces the four-to-six-x. Not the model. The loop.

This is not a new idea. It is a very old one.

Before compilers, programmers wrote machine code – actual binary instructions fed through punch cards or paper tape. You submitted a job. You waited hours. The next morning you came back to a printout. The feedback loop was a day long. Not because the programmers were slow. Because the machine ate jobs in batches and returned results in batches. That was just physics.

FORTRAN arrived in 1957. The idea was simple: let the programmer write something close to human intent, and let a program translate it to machine code. The feedback loop collapsed. You could write, compile, see the error, fix it, and compile again – all in the same session. That compression, more than any feature of FORTRAN itself, is what made modern software possible. Not intelligence. Latency.

What Anthropic is calling agentic coding is the same compression happening again. The distance between "I want this function to do X" and a running, tested implementation has gone from hours to seconds. The programmer describes intent. The agent translates it, runs it, fixes it, and reports back. Same loop, compressed further still.

Hardware never got FORTRAN.

This spring, venture capital finally gave the gap a category name. General Catalyst published the piece that made "software for hardware" official – a term with a funding thesis behind it. Maker Faire Rome ran a stage track called "atoms meet AI." Search either phrase today and you'll mostly find the pieces that coined them. The naming is new. The wall is not.

Adam – a YC W25 company – is the closest thing so far. Their agent takes a plain text description and produces parametric CAD in Onshape in seconds. "Reduce the wall thickness by two millimetres and add three M4 bolt holes at 30-degree intervals." Done. What used to require an hour in SolidWorks takes a sentence.

That part of the loop is starting to look like software.

A CoLab survey this year put a number on how uneven the rest of the promise still is: ninety-five percent of engineering leaders call AI adoption essential to their work. Three percent of hardware companies report measurable gains from it. The three percent is doing the CAD half. Nobody has cracked the atom half.

Then you hit the supplier boundary.

The CAD file leaves your screen and enters a different world. A world with tooling lead times, minimum order quantities, machinists who work business hours, and customs delays that don't care about your sprint. CNC machining from an overseas supplier takes four to eight weeks. Domestic, seven to twelve days for simple parts. Injection moulded prototypes, two to six weeks just for the mould.

The agent is instant. The atom is not.

You cannot run the hardware loop a hundred times while you make coffee. You can run it once, then wait. Then run it again. The compounding that makes agentic coding powerful is a property of a zero-latency feedback channel. Hardware's feedback channel has physical latency baked into the physics. It can be shortened. It cannot be zeroed.

There is a partial answer. It does not solve the problem but it narrows the gap.

3D printing. For the right geometries, you can go from agent-generated CAD to a physical part in hours. The first validation loop – does this geometry even make sense? does the clearance work? – collapses from weeks to an afternoon.

My clamp adapter is exactly that kind of geometry. An afternoon on a printer, not a month at a machine shop. And still the part doesn't exist – because even the cheapest tier of the loop has friction the software side forgot decades ago. Find the printer. Level the bed. Babysit the first layers. Every step needs a human to show up. Cheap is not the same as automatic.

The procurement loop is closing too. Xometry, Hubs, and Protolabs all have APIs. In principle, you can write a script that generates a CAD file, submits it for instant pricing, and places the order – without a human touching the keyboard. The infrastructure for agent-driven manufacturing procurement exists. The gap is between the API call and the finished part: someone still has to make the thing.

The factory that works like a codebase – intent-driven, fast-iterating, agent-writable – needs a compiler. The compiler is not the CAD agent. Adam is FORTRAN's syntax. The compiler is the closed feedback loop that lets an agent iterate on physical geometry at something closer to software speed.

We don't have it yet.

The STEP file in that repo is not a failure. It is the benchmark. Seconds to describe the part. Months – and counting – to hold it. That ratio – instant intent, slow atom – is where the next decade of manufacturing tooling has to focus.

Software got its compiler in 1957.

Hardware is still waiting.