In 5 Years, All Engineers will be Systems Integrators

Within five years, engineering will undergo a fundamental transformation. Most engineers will no longer design or build. They’ll integrate.

About 70% of engineers will evolve into what we might call systems integrators. These professionals won't invent every component, but they will specialize in making diverse technologies work seamlessly together.

What is Systems Integration?

Historically, systems integration has primarily involved connecting hardware, software, and communication protocols, particularly within manufacturing environments. Integration includes tasks such as enabling sensors to communicate with PLCs, visualizing industrial processes with SCADA systems, and securely linking factory floors to digital networks to ensure smooth and efficient operations.

I’ve lived both lives. As a former Automation Controls Engineer turned software developer, I see the writing on the wall. Software is becoming incredibly easy to generate with Large Language Models(LLMs). The hard part now is integrating that software into larger systems.

Software Integration as the Bottleneck

Previously, software developers spent most of their time writing and debugging code. With tools like Cursor and GitHub Copilot, coding has become faster, intuitive, even playful. Developers chat with their codebase and can monitor the changes being performed. Developers now generate applications in hours, what Andrej Karpathy calls "vibe coding."

Karpathy, former head of AI at Tesla, described the shift best when deploying his side project, Menugen:

“Vibe coding Menugen was exhilarating... but building a modern app is like assembling IKEA furniture from the future. There are all these services, docs, API keys, pricing tiers... I spent most of my time not in the code editor, but in the browser, configuring and gluing a monster together. All of this work isn’t even accessible to an LLM.”

These LLMs struggle with integration tasks largely due to the nature of training on existing data, while documentation on 3rd party products are constantly changing. In addition, the custom configurations of software and hardware, make every problem unique.

The true challenge of software development now lies in integrating and deploying it. I've experienced this myself with launching a small app I built called Quick Tea. I spend my time guiding the LLM to generate working code, while I dug through the documents to integrate APIs for configuring databases, payments, and 3rd party software. The same way I used to dig through docs to integrate lets say a sensor over MODBUS. 

A Brief History of Systems Integration

Systems integration emerged as advancing layers of technology began entering the manufacturing world.

• 1801: Jacquard’s loom introduced punch-card logic, automating textile manufacturing.
• 19th century: Watt’s steam governor introduced feedback loops (early PID control).
• Early 20th century: Relay logic managed manufacturing automation (e.g., Ford’s assembly lines).
• 1968: Dick Morley’s team introduced the first Programmable Logic Controller (PLC), radically simplifying industrial automation.
• 1970s-80s: SCADA and Distributed Control Systems (DCS) digitized control rooms, managing remote and complex industrial processes.
• 1990s onward: Networking advancements like OPC, Ethernet, and standards like ISA-95 connected factory floors to business IT.

Throughout these stages, the integrator evolved from a specialist electrician into a versatile generalist. One equally comfortable with wiring motors and configuring data networks. One who has successively added skills in circuit design, ladder logic programming, and networking. The next tool will be basic software development. It will begin with the writing of very basic scripts with the aid of LLMs. But it will grow from there.

But it's just software, right?

Anthropic introduced the Model Context Protocol(MCP) in November 2024 as an open source framework to standardize the way LLMs integrate with external tools, systems, and data sources. Every tool an Engineer uses can now be accessed by these AI models with MCP. MCP enables LLMs to potentially use tools like SolidWorks and Altium, commonly used by mechanical and electrical engineers. Just as software developers chat with their codebase now, mechanical engineers will be able to chat with their Solidworks assemblies to create modifications and update parts. 

Anything done on a computer is now a training vector. So even soft process related tasks will, to some degree, be automated.

The AI Allergic

Now I know many non-software engineers, especially those working in automation, tend to have an allergic reaction to AI. This is primarily due to its nondeterminism and error rate, which conflict with the dangers of having a robot in production. But it is precisely because of these imperfections that humans will remain in the loop. For the foreseeable future, we'll need a system integrator to bridge the gap between what AI can generate and what actually works.

Despite the skepticism, the use of AI tools will continue to grow because the gains in productivity and reduced engineering hours are too significant to ignore. But, to be very clear, engineers should not fully surrender control.

As Balaji Srinivasan put it:

0% AI is slow. But 100% AI is slop. So the optimal amount of AI is actually between 0-100%. The exact figure varies by situation, but just the idea that 0% and 100% are both suboptimal is useful. It's the Laffer Curve, but for AI.

Why 5 Years?

I predict that 70% of engineers will transition into systems integration-like roles within five years.

Why five?

Because we have a clear trajectory on how to improve these models through scaling laws. These laws, observed across multiple architectures, show that as you increase model size, data, and compute, performance improves predictably. New generations of LLMs are being released roughly every six months. Each iteration brings better reasoning, broader tool use, more accurate code generation, and increasingly general capabilities. In five years, we’ll be roughly ten generations ahead. Each one trained on deeper datasets and increasingly domain-specific workflows, including mechanical, electrical, and process engineering tasks.

The 30%

Not all engineers will become integrators. There will still be pure research. New physics, synthetic biology, and AI model design will still demand original thought and experimentation. This is where the frontier remains.

But most engineers won’t live on the frontier. They’ll live in the valley just below it, where AI will flood the landscape with drafts, schematics, and prototypes. And their job will be to sift, select, and stitch them into something that actually works.

Integration will become the dominant act of creation.

The Glue, The Generalist, The Engineering Gods

Glue work, long dismissed as "not real engineering", will suddenly be the part that matters. Visit any manufacturing floor, and you will see the metaphorical "tape" holding things together. Because integration is where abstraction meets constraint. It’s where GPT’s 95% solution confronts hardware quirks, edge cases, and real user needs.

The best integrators will not be mere middlemen holding things together. They will be generalists with deep tool belts. Not just because they understand a broad range of domains, but because they will know how to wield AI tools that few others can. They'll speak both Modbus and MongoDB, both torque curves and REST APIs. They won’t just be engineers. They’ll be architects with near infinite leverage at their fingertips.