First principles: logical work will eventually be done by AI — why IC design is next in line

A better question: what does AI actually use to eat an industry?

When the wave hits you, there are usually two reactions. One is anxiety — the sense that you're about to be made obsolete. The other is curiosity. Rather than keep asking "will AI replace me," I'd rather step back and ask something more fundamental: what, exactly, does AI use to eat an entire industry?

I tried to reason about this from first principles. First-principles thinking means breaking something down to the lowest layer that can't be broken down any further, and then reasoning up only from that floor — not from analogy, not from "everyone says so," and not from "this field has always worked this way."

Broken all the way down, the conclusion I reached is actually quite plain:

Anything logical basically has a chance of being replaced — and surpassed — by AI. AI can learn to make logical judgments and repeat them, so from first principles these things will naturally be taken over by AI; there's not much arguing with it.

It sounds like a truism, but it's actually powerful. It turns a mystical-seeming prediction — "which industry will AI eat" — into a question you can check item by item: what fraction of the work in this industry is "logical"?

What "logical" concretely means

I split work into two piles — what AI is already eating, and what it still can't quite chew. The dividing line isn't "hard vs. easy," it's "does this thing have logic to it" — and more concretely, these three traits:

• Generalizable. The "experience" behind it is really a set of rules that can be written down, one by one — not pure, unspeakable intuition.
• Verifiable. Once it's done, there's a clear right-or-wrong — does it run? did the tests pass? is the spacing legal? — instead of something only a person can "feel out."
• Precedented. There's a large body of prior cases to learn from, rather than a genuine, no-precedent "first time."

As long as something lands in all three, it has logic to it; and anything with logic to it, AI can learn, can repeat, and will keep getting better at.

The reason software is the first and easiest thing for AI to eat isn't that software doesn't matter — it's that almost the whole of it falls on the left: it's pure text, it has clear right-or-wrong (does it compile, do the tests pass), and there's a vast public corpus to learn from. I happen to work in software, which is why I'm in the front row — not because I'm special, but because what I do happens to suit AI's appetite most.

So — who's next in line?

Once you see the split this way, "who's next" stops being mystical. It becomes an almost measurable question: the field where the "generalizable, verifiable, precedented" pile makes up the higher fraction is the field closest to the front of the wave.

Follow that line down, and an answer surfaces in my mind — IC design.

It's a slightly counterintuitive answer. To an outsider (including me, not long ago), IC design looks like a high-barrier field that leans heavily on veteran instinct. From a complete set of design documents to a GDSII you can hand to a fab for tape-out, you pass through RTL, simulation, formal, synthesis, STA, DFT, place-and-route, DRC/LVS… and every stage has its own thicket of subtleties, many of them genuinely the residue of decades of senior engineers stepping on landmines.

But holding it up against that split, the more I look, the more I feel: the parts of IC design that "rely on experience" — the accumulation of that experience is, in fact, mostly logical.

IC-design "experience," taken apart, is mostly logic

A few examples off the top of my head:

• Why add a pipeline stage here? Because you need to break this critical path — that's something you can measure and compute.
• Why wire this reset that way? Because of metastability probability, because of timing — there's physics and rules behind it.
• Why can this DRC violation be waived and that one can't? Because their real impact on yield differs — that's a judgment you can classify and generalize.
• Is this LVS mismatch a genuine error, or a tool limitation? That, too, is a judgment that can be spelled out and checked.

In other words, this "experience" is rarely pure, unspeakable intuition. Most of it is layered, causal knowledge that can be written down and checked for right or wrong. And as long as something has that shape, it lands in the pile AI will eventually eat.

On this IC-design path, most of the experience I know of is logical — so being taken over by AI is only a matter of time.

I have to be honest: I'm not making this call as an IC expert — I'm not one. And precisely because I'm a semi-outsider, I don't carry the baggage of "this field is special, AI could never learn it." What I see is an information structure: a flow with clear inputs and outputs, where every step can be checked, and where most of the experience can be turned into rules. That structure is uncannily like software.

"Not 100%" doesn't mean "AI can't come in"

I don't want to overstate it. IC design certainly isn't 100% generalizable:

• the "tune it to just right" convergence instinct at advanced nodes;
• the part of analog design that leans on layout matching, on corners, on intuition you can't put into words;
• the trade-offs and QoR in very-large-scale design.

These are still hard bones in the short term — and exactly the places later posts in this series will take apart on their own. But "not 100%" doesn't mean "AI can't come in." Software was never 100% automatable either, and the wave rolled in anyway. As long as the "generalizable, verifiable" pile is a big enough fraction, the industry is already standing in the direction the wave is traveling.

And one thing accelerates the trend: AI is radically changing the cost of turning experience into rules. Judgments that once took a senior engineer a long time to distill and pass down can now be distilled and accumulated, bit by bit, into something AI can use directly. That's exactly where Vibe-IC started for me — if IC-design experience is mostly logical, could I turn it, rule by rule, into knowledge AI can reuse?

This is a calm observation, not a battle cry

Let me end by softening the tone. The "who's next" in this post isn't schadenfreude, and it isn't a declaration of war on anyone — I stand in the front row myself, and I know exactly what it feels like to be hit by the wave. It's more of a calm observation, plus a choice: rather than stand on the shore waiting for the wave, go and build the thing the wave will carry forward.

And let me say this up front, so it isn't misread later: none of this has anything to do with "beating commercial tools." The first principle is that "logical work will eventually be done by AI" — not "who has to beat whom." How open source and commercial coexist, and why I believe open-source EDA can absolutely do it too — that's the next post's job.

Next time, I'll follow this first principle one step further, to an even more obvious version of it: the EDA tools themselves. If commercial software can do it, why can't open-source software? And what does an ecosystem where open and paid-commercial coexist actually look like?