AI Is Transforming Embedded Development—But Without Context, It’s Still Guessing

Artificial intelligence is reshaping embedded systems development, compressing timelines and automating everything from driver generation to test creation. As adoption accelerates, engineers say the real story isn’t speed, but whether AI understands the deeply specific, hardware-bound reality of embedded software.

According to a report from RunSafe Security, 80.5% of embedded teams now use AI tools, and 83.5% have deployed AI-generated code into production systems across critical infrastructure.

Beneath that momentum lies a growing realization, however. AI is powerful, but in embedded systems, power without context can be a problem.

Development Speed Is Surging

For Eugene Gover, Head of Embedded & C++ at Innowise, AI has already reshaped the engineering lifecycle.

“It's compressing the traditional V-cycle,” Gover said. “We are now working with AI to create code, tests, and hardware abstraction layers simultaneously.”

The impact is tangible, he says: validation cycles have dropped by as much as 25% to 30%, accelerating delivery timelines across projects. That speed only holds if engineers stay in control, he said.

“Teams that treat their AI like a junior engineer who requires supervision have a much better outcome,” Gover said, cautioning that AI-generated code can appear correct in simulation while failing on real hardware.

Firmware Is Becoming “Software” 

Traditionally, embedded engineers have dismissed AI tools as poorly suited to their domain. According to Jacob Beningo, an embedded systems consultant, that assumption is eroding.

“The hardware-touching code is maybe 20% of a modern firmware project,” Beningo wrote, arguing that most work now lives in application logic, state machines, and communication layers. The shift toward abstraction is what makes AI viable.

Beningo finds tools like Claude Code effective for embedded development, not because they “understand hardware,” but because they align with modern software engineering practices: large context windows, persistent project constraints, and workflows that integrate directly into developer environments.

Beningo describes AI as a force multiplier. It accelerates tedious tasks like parsing datasheets, generating drivers, scaffolding tests, and refactoring legacy code, turning multi-day efforts into hours.

But even he draws a line: AI cannot replace architecture, expertise, or validation.

The Core Problem: Missing Hardware Context

For David Perez, Software Director at Analog Devices, the fundamental issue is not capability. It is visibility.

“Every embedded engineer… has a story about the plausible-looking driver that compiled cleanly and failed at 2 AM on the bench,” Perez wrote.

That failure, he argues, is “a failure of context.”

General-purpose AI tools generate code that looks correct for a generic microcontroller. But embedded systems are not generic. They depend on specific silicon revisions, clock configurations, DMA mappings, memory layouts, and errata—details that are often invisible to AI.

The result is a dangerous illusion: code that compiles cleanly but fails in subtle, hardware-specific ways. Part of the disconnect stems from how AI tools are built and evaluated.

“If you spend any time in the AI dev tools space, you’d be forgiven for thinking software development is synonymous with web development,” Perez noted.

Embedded systems operate under entirely different rules, however. They run on fixed hardware, often without operating systems, and must meet strict real-time constraints where failure can mean missed sensor data, broken control loops, or safety risks.

Errors don’t always surface immediately. They can emerge months later, in the field, under conditions that were never simulated.

A New Kind of Software Supply Chain Risk

As AI becomes embedded in development workflows, it is also being treated as a new software supply chain dependency.

“Traditionally, you were primarily focused on addressing third-party libraries and middleware. Today, you will also be concerned about what AI was trained on, if any proprietary code has been copied or replicated, and if there are any vulnerabilities within the AI that would not be evident in human-written code,” Gover said.

Organizations are responding by tightening controls, flagging AI-generated code for extra review, introducing earlier hardware-in-the-loop testing, and tracking code provenance more rigorously.

These concerns are reflected in the RunSafe report, where 53% of respondents cite security as their top worry and 73% rate AI-related risk as moderate or higher.

The Longevity Problem

In embedded systems, mistakes do not disappear quickly.

“In typical IT software applications, such as web-based ones or cloud services, if AI produces an exploit, you roll back within minutes or fix it within several hours,” Gover said. “In contrast, once AI has generated code in firmware for a medical device, an industrial controller or a vehicle's ECU and distributed that code to the field, that code will reside in the field for multiple years.”

This can mean a decade or more. That longevity turns small defects into long-term liabilities, especially when patch adoption is slow.

It also raises the stakes for AI-generated errors, particularly those tied to hardware interactions that are difficult to detect before deployment.

Rewriting the Workflow, Not the Code

Early research suggests that meaningful gains from AI in embedded systems may require deeper changes than simply adopting new tools.

Perez points to emerging practices where teams redesign workflows around AI pipelines, structuring project data so it can be parsed and used effectively by AI systems. Agentic AI, he writes, is the artificial intelligence most likely to disrupt the embedded space. 

Agentic systems can be given the goals and constraints of a project, and are complex enough to execute tasks within the context of embedded development. Rather than using AI to complete individual tasks, engineers can use agentic to redesign workflows, toolchains, and team coordination across the embedded development lifecycle. 

The industry is already shifting in response. According to RunSafe, organizations are investing heavily in automated analysis, AI-assisted threat modeling, and runtime protections designed to catch vulnerabilities after deployment.

The goal isn’t perfect code or faster development but resilience.