When Marc Andreessen wrote in 2011 that software was “eating the world”, he foresaw a worldwide substitution: innovative companies that used software replacing incumbents in industry after industry.
He saw early signs that companies that were providers or early adopters of Silicon Valley-developed software would outperform their peers. In his analysis, he extrapolated this trend to the world, and in 2026, it is obvious he was right.
Today, the question is no longer whether software would affect all industries (it did), but how AI will shape them this time around.
So let’s take the same approach of looking at the early trends and extrapolating from there.
When ChatGPT came out in late 2022, it quickly became clear to its early adopters that this was more than a toy, but rather another technology that had the potential to touch many industries.
In early 2023, I predicted that by the end of 2024 most knowledge workers would have a digital assistant. That happened: By October 2024 every Google search result included an AI summary, and ChatGPT reached 300 million weekly active users. Today, that number is well beyond 900 million.
While chatbot-like use of AI is already profoundly affecting private lives and the day-to-day tasks of people in many white-collar jobs, it is just the tip of the iceberg of a more profound change that is currently underway — so far mainly visible in a single industry.
While pretty much every business software tool nowadays ships with a chatbot, most of them are just gadgets. You type a question, the chatbot answers, you close it. Nothing changes in your project. You get nothing you couldn’t get from ChatGPT. When people share “magical” workflows on LinkedIn, they are usually a concatenation of hopping between tools or automatic repetitive tasks.
However, since December 2025, there is one industry that has shifted far more profoundly than the other areas: Software Engineering.
So, what is changing in that industry that is not happening anywhere else?
Agents that have access to and can modify actual work context.
Let me explain:
It was already clear early on that context-awareness, speed and computational abilities would be necessary properties of any useful “co-pilot” for real-world engineering.
Concretely, this means that the AI does not “wake up dumb” or need re-explaining every time it starts but can quickly pick up from existing work and that it can do work that is meaningful in a real-world work context instead of relying on the human to insert their knowledge and copy-paste data.
The distinction is simple: does the AI act on your data inside your work environment (Agent), or does it just talk about it (AI Chat)? When agents work and use tools on the user’s behalf, they turn question-answering machines like ChatGPT into actual collaborators.
The first place this happened at scale was coding agents: released only in February 2025 as “Claude Code”, and since then transforming the software world as adoption has gone through the roof.
Today, these agents code entire features, review and ship them while humans are asleep.
Software engineers are still in charge of deciding what to build, but more and more of the actual execution is shifting from humans to machines. These are not minor changes to the way people in that industry work. It has gone well beyond reformulating emails or writing memos; it has changed the entire way every software engineer works on Earth in the past nine months.
Why has all of this almost exclusively been happening in a single industry?
I believe there are three main reasons why software development has been the first (and for now arguably only) industry that the big AI labs focused on:
•The people building the AI models and the tooling around them are software engineers themselves. It’s the domain they know best, so they can iterate quickly and build great products for themselves first.
•Some AI labs believe that if they make coding better, they gain a major competitive advantage, since they can then build better AI faster using those same tools. Strong incentive.
•As Andrej Karpathy noted, when the correctness of a task is easy and cheap to verify (which is exactly what automated tests and compilers do for code), it is easy to optimize an AI to perform well at that task.
That last point especially drives home why software engineering has been such an easy target. Code is the only engineering artifact that is natively machine-addressable and lives in a single place; it is “only” text (which LLMs understand very well), but can be executed and tested, so its outcomes can be automatically verified.
While this explains why the first wave of agentic work was directed towards software engineering, the interesting question that arises now is in which areas the lessons learned and tools built for software engineering can best be reapplied in a second wave of transformation.
Here are some criteria:
•Most advances in the past three years in AI have been made in Large Language Models (LLMs) that can input and output text extremely well. So, the methods and tools developed in software engineering will be most applicable in tasks that rely heavily on complex text.
•Agentic workflows work best when the AI agent has direct access to a centralized repository that contains the context of what the user is trying to accomplish. In coding, this is available in specification files, comments or even the code itself.
•The AI agent needs to be able to actually interact with the data (traverse it, make suggestions, etc.) using the so-called “harness” to assess the potential impact of changes and propose them autonomously for the user to review and confirm.
While it is immediately obvious that industries such as marketing, legal, translation and others that fulfill those criteria will be disrupted next by reusing the methods and tooling invented for software development, I want to focus on what is next in the world of engineering.
The area in hardware engineering that comes closest to coding is Requirements Engineering (RE):
•Requirements describe in text form the product the engineers are trying to develop.
•Requirements Management Systems are central repositories that contain the logically connected context of the entire design of a product across disciplines.
•A well-connected AI agent can navigate requirements across multiple hierarchies, connect to their implementation and verification, and based on this, assess and propose meaningful changes.
This is the area in which an AI agent can assist engineers as a colleague. It allows hardware engineers to make the same leap that software engineers made in the past nine months:
•Software engineers went from using a “nice-to-have” chatbot that, with limited context, sometimes autocompleted some code, to defining high-level functions and seeing AI agents plan, code and test them end-to-end.
•Hardware engineers will go from checking and reformulating individual requirements to discovering and aligning the detailed design intent that can then be developed and manufactured in much quicker iterations.
In requirements engineering, the requirements are the context, and the correct setup makes them available to agents to work with.
Experienced engineers can then intuitively judge whether a product is well defined, and in the near future, simulation might even become the hardware equivalent of compiling. You can simulate with significant accuracy whether electronic circuits work, how mechanical loads are distributed, how heat and fluid flow behave. Then, formalized design rules can automatically verify whether a design meets its specs.
One can imagine a future where most hardware design is verified automatically and only higher-level functions are checked by hand; much like manual QA still exists in the software world.
Three things changed in the last twelve months, and together they make agentic hardware engineering real.
First, models got good enough at structured editing that they can be trusted to propose changes inside an engineering tool, not just talk about one. Tool use is no longer a novelty.
Second, hardware engineering tools are exposing their content as structured data. This is boring infrastructure work that’s mostly invisible from the outside, but it is the precondition for providing context to agents that can then build on top of it.
Third, we now know what coding agents are capable of once you connect a tool-using AI model to the right harness: developing entire systems under the guidance of experienced engineers.
So my prediction:
By the end of 2026, the engineering tools for hardware product development will ship the first useful agentic capabilities that let engineers make high-level decisions on requirements and have agents break them down for engineers to approve.
By the end of 2027, the race we have seen in coding will have broken out in hardware too. Tool vendors will be competing to offer solutions that let engineers oversee the entire development cycle from early requirements engineering to assisted implementation and automated verification.
By the end of 2030, the most innovative companies will be closing the loop between theoretical engineering and iterative production, making sure the designs that the AI agents help develop actually translate quickly into physical prototypes that can then be tested automatically and from which the lessons learned can be funneled back into the AI-assisted development cycle.
Picture two engineers at a mid-sized hardware company developing, say, a new industrial sensor module.
One is a requirements owner — a senior engineer accountable for the sub-system requirements of the sensor. The other is a design owner — an electronics engineer responsible for developing the board that makes it do those things. Today, these two people spend a depressing fraction of their week translating between each other’s artifacts. In 2027, they won’t.
The requirements owner sits down on Monday morning. Overnight, a colleague two levels up adjusted a handful of top-level system requirements — tightened the operating temperature range, added an EMC clause, and relaxed a power budget. Her queue is already waiting…
The agent has compared the new parent requirements against her sub-system architecture tree, identified eleven sub-requirements that no longer line up, drafted concrete edits for each, and grouped them into three coherent review batches for software, thermal and PCB aspects. Alongside each batch, the agent has flagged the test procedures that would need updating and the verification-matrix entries that would shift as a result. She approves two batches in fifteen minutes. The third she rejects in one sentence, because the agent missed a regulatory constraint; the agent redrafts on rejection. Nothing changes in the system until she clicks approve.
Changes that used to take weeks to ripple through her sub-system tree had already been resolved before she sat down.
Across the floor, her electrical design owner opens his ECAD environment. Alongside his schematic, the live requirements his board has to satisfy are right there. Not a PDF export from three weeks ago, the live ones. When the temperature range tightened overnight, his agent already flagged which components are now out of spec, drafted a note explaining which alternatives would close the gap, and listed the bench tests that would need rerunning.
He spends his morning on the two changes that actually need his engineering judgment, instead of on the twenty that don’t. For the first time in months, the afternoon is for design.
Neither engineer has been replaced. Both have been promoted from individual contributor to lead of their own team of AI agents. The busywork, the cross-referencing, the bookkeeping, the polite chasing of stakeholders — all delegated to agents that never get tired of it. What’s left is the part of the job that made them want to be engineers in the first place.
Andreessen’s 2011 thesis was about who builds the world’s products. Software companies, he said, would build them, or buy the ones that did.
The agentic shift is about how those products get built. The next decade of hardware will not be defined by which company has the smartest engineers — every company has smart engineers. It will be defined by which company’s engineers have the most leverage.
And leverage, in 2027, means a team of agents working on your data, in your tools, surfacing the right suggestions at the right time.
The age of agentic hardware engineering has begun.
Personal plug:
This is the world my team and I have been building towards at Altium’s Requirements Portal. And we have just launched Agentic Requirements Engineering.
Obviously not as a chatbot pinned to the side of the app, but as agents that work directly on your live requirements: reading the current tree, proposing concrete edits, applying your team-defined skills, and surfacing every change as a suggestion you approve.
The interesting part isn’t the product. The interesting part is how the job of an engineer changes.
Thanks for reading Assisted Everything! This post is public so feel free to share it.