AI 2026 – PJFP.com

This is part two of Naval Ravikant’s conversation with frontier founders Guillermo Rauch of Vercel, Blake Scholl of Boom Supersonic, and Max Hodak of Science. Where the first part argued that you should waste tokens to save time and that the job of an engineer is now to build the factory rather than the output, this segment drags that thesis out of pure software and into atoms. The question on the table is what happens to hardware when models can vibe code the spreadsheets, the simulations, and eventually the step files and PCB layouts that aerospace, semiconductors, and biotech are built on. The full conversation is on the Naval Podcast YouTube channel.

TLDW

Blake Scholl describes how Boom Supersonic took hardware engineering workflows that used to live in siloed Excel spreadsheets and VBScript on individual laptops, with handoffs done by email like it was the 1990s, and turned them into versioned, testable software. The new model is that software engineers build the architectures and the tools while hardware engineers vibe code their own domain-specific pieces, which collapsed a turbine-blade analysis that once took one engineer one day per blade into something where two engineers can design an entire jet engine in real time. Naval generalizes this into the cataclysm of enterprise software: there is no longer a startup that can sell you hardware collaboration tools because companies just code the exact thing they need on demand, and even spreadsheets are cooked because they only existed as a proxy for custom software nobody could previously afford to build. Blake predicts that within 2026 AI will move from generating software to generating step files and PCB layouts, which reshapes mechanical and electrical engineering. The group debates China’s open-source push as a way to neutralize Silicon Valley’s software advantage and protect its hardware and supply-chain superiority, lands on the point that if you fall behind on generating software you fall behind on generating everything, and Guillermo notes that frontier coding intelligence still dominates real usage while cheaper models like Gemini win at scale for support and browser automation. Max Hodak explains Science’s vertical integration, including a captive MEMS foundry on the East Coast, because the most innovative hardware cannot be bought off the shelf, and argues that software still needs hands since a model that cannot make physical things hits real boundaries. The conversation closes on the shift from writing to verifying: junior engineering got absorbed by agents while juniors got promoted, the same way paralegals could be seen as fired or promoted, and humans across law, engineering, and operations are becoming the verifiers who sign off on systems they did not write line by line.

Thoughts

The most important shift in this segment is that vibe coding stops being a software-industry story and becomes a deep-tech story. In part one the examples were Postgres, ClickHouse, and deploy targets. Here Blake Scholl is talking about turbine blades that change shape when they heat up, and the brutal fact that converting between cold and hot geometry, and between aerodynamics and structures, used to eat one engineer for one full day per blade in an engine that has a thousand blades. That is the kind of math that quietly kills ambition. When he says two engineers can now design an entire jet engine because the structural and aerodynamic results update in real time as you change the geometry, that is not a productivity improvement, it is a change in what a small team is allowed to attempt. The interesting move is the division of labor: software engineers build the architecture and the framework because they understand systems and separation of concerns, and the hardware engineers vibe code the pieces only they understand. Nobody has to become both.

Naval’s “cataclysm of enterprise software” is the most investable idea in the episode, and it is darker than it sounds for anyone selling B2B tools. His claim is that the entire category of internal collaboration software is being eaten from the inside, because a company that can generate exactly the tool it needs on any given day will not pay a vendor for an approximation of that tool. His follow-on that even spreadsheets are cooked is the sharpest version of the point. The spreadsheet won for forty years precisely because it was the closest thing to custom software that a non-programmer could produce. Remove the constraint that custom software is expensive and the spreadsheet loses its reason to exist. The counterweight, which the group raised in part one with the block-economy thesis, is that the infrastructure primitives agents reach for get more valuable, not less. So the safe place to build is not the collaboration layer on top, it is the primitive underneath.

The China discussion is the geopolitical center of the conversation and it lands on a genuinely uncomfortable insight. The argument is that China leans into open-source models not only because it is a model or two behind, but because open weights neutralize Silicon Valley’s software advantage and let China lean on what it already dominates: hardware, supply chains, and component ecosystems. If software can be generated on demand from open models, then the country with the factories wins the stack. The sharpest line is that if you fall behind on the ability to generate software, you fall behind on the ability to generate everything, because software is now upstream of every hardware pipeline. That reframes the open-versus-closed debate as a question about who controls the means of producing the means of production. It also quietly flatters the American frontier labs, since the same logic says self-improvement requires frontier coding models, and on that narrow axis the consensus at the table is that the Chinese models are not yet in the race.

Max Hodak provides the necessary cold water, and it is the most grounding contribution in the episode. Everyone else is describing software eating the design layer, and Max points out that you still have to make the thing. Science owns a captive MEMS foundry on the East Coast not as a flex but because there was no other way to do the packaging and assembly for products that approach a single block of covalently bonded matter. His framing that the software still needs hands is the real boundary condition on all the AI-eats-everything talk: a model can be smarter than every engineer in the building and still be unable to deposit a layer, bond a wafer, or pass a regulatory inspection. The optimistic version, which he also makes, is that he has instrumented the foundry so that as models improve, the gains show up immediately in cell engineering and material science. The pessimistic reading is that the physical world remains a hard rate limiter, and the companies that own the atoms will capture more of the surplus than the companies that only own the bits.

The closing thread on verification is where the whole conversation resolves into a job description for humans. Guillermo’s point that the biggest problem in software is mountains of slop arriving as a pull request, and that the answer is not pretending to read every line but being able to say “I am signing off on the consequences of this PR, and I wrote the harness, the simulations, the proofs, and the type checkers that let me,” is the most practically useful idea in the episode. It generalizes cleanly. The lawyer you trust is not the one who wrote every clause by hand, it is the one putting their reputation on the line that the document is sound. The production engineer who gets paged at 3am is the one signing off that the system is safe to ship. As models absorb the junior tier of every knowledge profession, the surviving human role is the verifier who carries the accountability. That is a promotion for the people who can hold it and an extinction event for the people whose value was doing the work nobody now needs done by hand.

Key Takeaways

The factory framing from part one carries straight into hardware: you are judged on whether you build the system that produces multiplicative outputs, not on the single artifact, and the real multiplier was always 100x or 1000x, not 10x.
AI completely changes the role of software and hardware developers rather than just speeding either one up.
A huge amount of hardware engineering lives in complex Excel spreadsheets and VBScript on individual engineers’ laptops, with no source control, no automated testing, and handoffs done manually over email. It is software that is not treated as software.
Boom Supersonic’s move from day one was to turn traditional hardware engineering workflows into real software frameworks that are automatable and repeatable, to drive down the cost of iteration.
The old bottleneck was never being able to afford enough software engineers to build those frameworks. AI removes that constraint.
The new model: software engineers create the architectures because they understand systems, algorithms, and separation of concerns, and hardware engineers vibe code the domain pieces only they understand.
A turbine blade is cold when it starts and hot when it runs, so it changes shape, and you must design both the cold and hot geometry across aerodynamics and structures. Classically that was one engineer, one day, for one blade, in an engine with a thousand blades.
With software and hardware people combined, you can now change blade geometry and see the structural and aerodynamic results in real time, which lets two engineers design an entire jet engine.
Naval’s cataclysm of enterprise software: no startup can sell hardware collaboration tools anymore because companies just code the exact thing they need at any given time.
Even spreadsheets are cooked. Spreadsheets won only because nobody could build custom software, so a spreadsheet full of VBScript was the closest available approximation. Remove the cost barrier and the approximation loses.
Engineers are moving from Excel to Python models that produce believable simulations of physical systems.
AI can generate software today, but within 2026 it is expected to generate step files and PCB layouts, which opens up mechanical and electrical engineering as the next frontier.
The hardware software boon is biggest for small gadget and parts companies that historically shipped bad software because they could not afford good software. Now they can ship good-enough software, or skip the human front end entirely and expose hardware agentically for voice and agent control.
China goes all in on open-source models partly to neutralize Silicon Valley’s software edge: if software can be generated on demand from open weights, China’s hardware and supply-chain superiority stops being offset by a software disadvantage.
Other reasons cited for China’s open-source push: it is a model or two behind, it is distilling models, and the government has a history of funding efforts that lift the whole ecosystem, especially in network-effect businesses.
Open-source heft is coming almost entirely from China. OpenAI is not open, Grok publishes models but is seen as a model or two behind, Google’s local models are not very competitive, and Anthropic is not known for open-source releases.
Without frontier coding models you do not get self-improvement, and if you fall behind on generating software you fall behind on generating everything, because software now sits upstream of every hardware pipeline.
Real AI gateway usage shows open models do get used, but the top is heavily dominated by frontier intelligence.
Frontier intelligence at the right cost and performance slaps at scale. Gemini models are underrated and excel as industrial production models for support tasks and browser automation, even if they are not the top pick for coding.
For pushing the frontier you need the best possible coding model, which is now only two or three models, and the Chinese models are not among them.
One contrarian view at the table: use DeepSeek for 97% of tasks because it is cheap, run it repeatedly for harder problems, and reserve frontier models for the most advanced work. The counterargument: intelligence is an unalloyed good, mistakes are invisible and costly, and a smarter model is always cheaper than a person, so you default to the most intelligent option.
Always wanting the most intelligent model risks creating a monopoly or oligopoly in AI, because when two models disagree you cannot tell which is right, so you trust the smarter one and stop asking the weaker one.
Vertical integration is forced, not chosen: if you cannot buy it, you have to make it. The preference is always to buy when a vendor offers a service at a great price, like PCBs from Asia.
The closer a product gets to a single block of covalently bonded matter, the better it performs: lower power, smaller, higher performance, longer lasting. The components for that level of integration simply are not available to buy.
Science owns a captive MEMS foundry on the East Coast, bought because there was no other way to do the packaging and assembly the company needed.
One of the biggest near-term AI impacts inside hardware companies is regulatory and documentation work: tracing which of thousands of ISO standards apply used to occupy a regulatory and quality team for months, and now AI just knows.
Software still needs hands. A model can be smarter than us and still hit real boundaries if it cannot physically make things, which is why Science has instrumented its foundry so model improvements show up immediately in cell engineering and material science.
Basic legal work is already going away. People have stopped asking lawyers for NDAs and routine agreements, because law is spaghetti code in English with no real APIs, and the basic tasks are handled by AI.
Junior engineers got promoted to senior engineers while junior engineering itself got taken over by agents. The same framing applies to paralegals: fired, or promoted to senior lawyers who now spend their time thinking about the law.
What you value in a lawyer is a trusted authority who puts their reputation on the line, not someone who read every clause. The same trust model is coming to engineering.
The biggest problem in software engineering today is mountains of slop arriving as a pull request. The old norm of reading every line of a PR is gone.
The new standard is being able to say “I understand and I am signing off on the consequences of this PR,” backed by the test harness, simulations, proofs, and type checkers you built, even without reading every line.
Embrace a world where code is spaghetti you do not fully understand, but build the evaluators that give confidence, and rely on production engineers to sign off because someone gets paged if the system goes down.
Creating software is easy from zero to one. The hard part is a thousand days from now: is it secure, tested, production grade, and performant, and are you still motivated to invest the tokens to maintain it in prod?
Humans are becoming verifiers. The same way models are trained on good verification data, the old functions of lawyers, engineers, and operations people are moving to verifying the stack and standing behind it.

Detailed Summary

Turning Hardware Engineering Into Software

Blake Scholl opens by describing how AI completely changes the role of software and hardware developers at Boom Supersonic. From day one the company tried to take traditional hardware engineering workflows and turn them into software. For anyone who has not been around hardware engineering, he explains that an enormous amount of it happens in complex Excel spreadsheets on individual engineers’ laptops, sometimes with VBScript code, all of which is actually software but is not treated as software. There is no source control, no automated testing, and when an aerodynamicist hands work to a structures engineer it is done manually with a spreadsheet over email, like it is the 1990s. Boom started building software frameworks to automate and make those flows repeatable so the cost of iteration would drop, but progress was slow because the company could never afford enough software engineers.

Two Engineers, One Jet Engine

The mind-blowing change, in Blake’s words, is a new division of labor. Software engineers create the architectures because they understand systems, algorithms, and separation of concerns, and then hardware engineers vibe code the pieces that draw on what they uniquely know about hardware. The result is wildly different productivity for small teams. His example is the turbine blade: it starts cold and gets bigger as it heats up in operation, so you have to design both the cold shape and the hot shape, converting between them and between structures and aerodynamics. Classically that was one engineer, one day, for one blade of analysis, in a jet engine with a thousand blades, which means you simply could not do much. Now, with software and hardware people working together, you can change blade geometry and see the structural and aerodynamic results in real time, which allows two engineers to design an entire jet engine.

The Cataclysm of Enterprise Software

Picking up on the point that software engineers now build the tools and architectures for everyone else, Naval names what he calls the cataclysm of enterprise software. There is no longer a startup that can build and sell hardware collaboration tools, because internally companies just code the right things they need at any given moment. Even spreadsheets are cooked, he argues, because the reason spreadsheets succeeded is that no one could build custom software, so a spreadsheet stuffed with VBScript functions was the closest available approximation. With that constraint gone, the proxy collapses. He notes he has personally moved almost entirely from Excel to Python models where he can get believable simulations of things.

Generating Step Files and PCB Layouts

The next frontier, Blake suggests, is the thing AI has not reached yet but probably will within 2026: today it can generate software, but soon it will generate step files and PCB layouts, and when it comes for mechanical and electrical engineering that will be a whole other thing nobody has seen yet. On the hardware side this is described as a particular boon for the many small gadget and parts companies that historically wrote bad software because they could not make great software. Now they can make good-enough software, or skip a human front end entirely and expose the hardware agentically, so that an agent accesses it and a person controls the hardware by voice.

China’s Open-Source Bet and Hardware Superiority

This leads into one of the reasons China is described as going all in on open-source models. With hardware superiority, complex supply chains, and deep component chains, China’s logic is that if it can generate software on demand it no longer suffers a software disadvantage against Silicon Valley. That is framed as not the only reason: China is also a model or two behind, it is distilling models, and the government has a history of funding efforts that lift the entire ecosystem, especially in network-effect businesses. Ironically, the open-source heft comes from China precisely because OpenAI is not open, Grok publishes models but is a model or two behind, Google’s local models are not very competitive, and Anthropic is not known for open releases. The deeper point is that without great frontier coding models you do not get self-improvement, and if you fall behind on the ability to generate software you fall behind on the ability to generate everything, because generating software is embedded in every piece of the hardware pipeline.

Frontier Intelligence vs. Cheap Models

Naval raises a dinner-table argument from the night before, where someone claimed you will use DeepSeek for 97% of things because it is cheap, run it repeatedly when you need more intelligence, and reserve OpenAI or Anthropic for the most advanced tasks. Naval pushes back: intelligence is an unalloyed good, you always want more of it, model mistakes are invisible, and a smarter model is always cheaper than a real person in real time, so you default to the most intelligent model available. He notes the downside is that this tends toward a monopoly or oligopoly, because when two models give different answers you often cannot tell which is correct, so you trust the smarter one and gradually stop asking the weaker one. Guillermo confirms with AI gateway data that open models do get used, but the top is heavily dominated by frontier intelligence. His caveat is that frontier intelligence at the right cost and performance slaps at scale: Gemini models are underrated but are excellent industrial production models for support tasks and browser automation, while for pushing the frontier you need the best possible coding model, now only two or three models, and the Chinese models are not in that set.

Vertical Integration and the Captive MEMS Foundry

Asked about his push into vertical integration and extreme urgency, Max Hodak explains that for many things you cannot buy what you need, so you have to make it. The preference is always to buy when a vendor offers a service at a great price, and he points to PCBs, which are basically free and available in unlimited quantity from Asia. But the closer a product gets to being a single block of covalently bonded matter, the better it is: lower power, smaller, higher performance, longer lasting. The components for that level of integration are not available, so to innovate beyond piecing together off-the-shelf parts you have to learn to do it yourself, which shows up as vertical integration. Science owns a captive MEMS foundry on the East Coast, bought because there was no other way to do the packaging and assembly work the company wanted.

Software Still Needs Hands

Max expects AI to heavily affect all of this over the next few years, though it is not quite there yet. Ironically, one of the biggest impacts already seen is in regulatory interactions and documentation: figuring out which of thousands of ISO standards apply to a product change, and tracing it through, used to occupy a regulatory and quality team for months, and now the AI just knows. But for things like the surgical program or the MEMS fab, he argues the software still needs hands. It will be smarter than us, but if it cannot make things, those are real boundaries. Science has instrumented its foundry and many other parts of the company so that as models get better, the improvement shows up immediately in cell engineering and material science.

Lawyers, Paralegals, and the Promotion of Junior Work

The discussion turns to law as a parallel to engineering. It has been a while since anyone at the table generated a basic legal document using a lawyer. Routine work like NDAs and standard agreements is gone, because law is essentially spaghetti code that contradicts itself and has no real APIs, expressed in complicated English. Junior engineers got a promotion to senior engineers while junior engineering itself was taken over by agents, and the same framing applies to paralegals: you can say they were fired, or you can say they were promoted to senior lawyers who now spend their time thinking about the law. What you actually value in a lawyer is a trusted authority who went to law school and puts their reputation on the line when they tell you a document is legit.

Slop PRs, the Thousand-Day Problem, and Humans as Verifiers

Guillermo argues the biggest problem in software engineering today is mountains of slop ending up as a pull request. The old meme of reading every line of a PR is gone. In infrastructure he wants engineers to be able to say they understand and are signing off on the consequences of a PR, backed by the test harness, simulations, proofs, and type checkers they wrote, so they have confidence it will be safe in production even without reading every line. There is a world where everyone embraces that the code is spaghetti nobody fully understands, but builds the evaluators that give confidence and relies on production engineers to say it is fine to ship, because someone gets paged if the system goes down. The further warning is that creating software is easy from zero to one, but a thousand days from now you have to ask whether it is secure, tested, production grade, and performant, and whether you are still motivated to invest the tokens to maintain it in prod. The resolution is that humans are becoming verifiers, the same way models are trained on good verification data, and the old functions of lawyers, engineers, and operations people are moving to verifying the stack and standing behind it.

Notable Quotes

“What I found is it completely changes the role of software and hardware developers.”
Blake Scholl, on how AI reshaped engineering at Boom Supersonic.

“If you want to hand something off from like an aerodynamicist to a structures engineer that’s done manually with like a spreadsheet over email. It’s the 1990s. It’s terrible.”
Blake Scholl, describing the state of traditional hardware engineering workflows.

“It allows two engineers to design an entire jet engine, which is just wildly different.”
Blake Scholl, on collapsing turbine-blade analysis with real-time structural and aerodynamic feedback.

“Even spreadsheets are kind of cooked, right? Because the reason spreadsheets were successful is that no one could build custom software.”
Naval Ravikant, on the cataclysm of enterprise software.

“Right now it can generate software, but soon it’ll be able to generate step files and PCB layouts. And when it comes for mechanical and electrical engineering, that will be a whole other thing that we haven’t seen yet.”
Blake Scholl, on the next frontier for AI in hardware.

“If you fall behind on your ability to generate software, you fall behind on the ability to generate everything.”
Naval Ravikant, on why software now sits upstream of every hardware pipeline.

“Anytime I’m working to push the frontier you need the best possible coding model, and that’s basically now like two or three models, and the Chinese are certainly not in it.”
Guillermo Rauch, on where frontier coding intelligence actually lives.

“You can’t buy it, so you got to make it somehow. The closer that our products get to being like a single block of covalently bonded matter, the better they’ll be.”
Max Hodak, on why Science is forced into vertical integration.

“The software still needs hands. It’s going to be smarter than us, but if it can’t make things, then those are real real boundaries.”
Max Hodak, on the physical limits of AI in hardware.

“You need to be able to say I am signing off on understanding the consequences of this PR, or I wrote the test harness, the simulations, the proofs, the type checkers, to be able to say even without reading this, I have confidence it’s going to be safe in production.”
Guillermo Rauch, on what code review becomes in the age of slop PRs.

“Creating software is really easy 0 to one. But think about a thousand days from now. Is it secure? Is it tested? Is it production grade? And are you still motivated to invest all of those tokens in maintaining it in prod?”
On the long-term cost of software that is cheap to create and expensive to keep alive.

Watch the full conversation on the Naval Podcast here.

Tag: AI 2026

Vibe Coding Hardware: Naval, Guillermo Rauch, Blake Scholl, and Max Hodak on AI-Designed Jet Engines, Vertical Integration, China’s Open-Source Bet, and Why Humans Become Verifiers