Embedder
All news

The Next Battleground for Silicon Vendors Is Developer Experience

By Embedder ·

Two evaluation kits land on a firmware engineer's desk in the same week, both meeting the spec at about the same price. By Thursday one has a working sensor driver and a passing test on the board, and the other is still blinking an LED while someone digs through a 1,500-page reference manual for one clock setting. The second chip might be the better part, but it won't get the design win.

For decades, silicon vendors competed on performance, power, and price. Everything between unboxing a chip and running verified firmware on it (documentation, SDKs, drivers, board support packages, reference designs, debug tooling, support) counted as table stakes. That ordering made sense when every engineer ramped on a new part at roughly the same human speed.

Developer experience used to break ties between chips on the shortlist. Now it decides which chips stay on the shortlist long enough to be considered, and the reason is simple: agents.

In JetBrains' Developer Ecosystem Survey 2026, 90% of professional developers used AI coding agents at work at least weekly, and 68% used them daily. An engineer who closes tickets with an agent all morning expects that pace when bringing up a new chip in the afternoon. Hours spent clicking through a GUI configurator or searching a reference manual become part of how they judge the chip.

Trust hasn't kept up. In Sonar's 2026 State of Code survey, 96% of developers said they don't fully trust AI-generated code to be functionally correct. Firmware makes that gap especially expensive: a plausible answer can compile cleanly and still be wrong on the board. Engineers want faster answers, but they also need evidence.

A vendor that provides both benefits twice. Its own engineers can ship SDKs, drivers, and reference designs faster, and its customers can reach a working prototype sooner. Both shorten the path to a design win.

Compiling is not evidence

A wrong register value can compile, link, and flash without complaint. The failure might show up immediately on the bench, or six months later in the field. The compiler checks the code against the language. It can't tell an engineer whether bit 4 of a clock control register should be set on this silicon revision.

So an engineer evaluating a new part asks an agent for a driver, then asks where each value came from. Without the relevant documentation, there's no reliable way to distinguish a documented setting from a plausible guess.

That creates two requirements. Provenance tells the engineer where a decision came from: a register description, a table, a page. Verification tells them whether it behaves correctly on their board: a register dump, a scope capture, a current trace.

Neither is enough alone. A citation can point to a mistake in the datasheet. A bench test can pass because the code relies on an undocumented quirk. An agent doing firmware work needs to show the source behind its decisions and the measurements supporting its results.

What vendors have shipped, and where it stops

Several large MCU vendors now provide tools that connect AI agents to their documentation and development environments, often through the Model Context Protocol, or MCP:

  • Nordic Semiconductor's MCP servers expose nRF Connect SDK documentation, API references, device configurations, and field data from nRF Cloud. They work with Claude Code, Cursor, GitHub Copilot, and other assistants.
  • Texas Instruments ships MCP servers inside Code Composer Studio for building projects, running the debugger, using SysConfig, and reading serial output.
  • Microchip's MPLAB AI Coding Assistant for VS Code has an agent mode and MCP tools for documentation, example projects, and supported evaluation boards.
  • Analog Devices' AI Debug Assistant, in preview in CodeFusion Studio, connects MCP-compatible agents to live debug sessions for hardware inspection and fault diagnosis.
  • Renesas made Renesas 365, powered by Altium, generally available in March 2026. The cloud platform connects device selection, system design, and lifecycle management, with AI guidance built in.

Developers are also filling gaps themselves. Open-source tools for STM32 include GDB-based debugging on real hardware, with flashing and register inspection.

These tools vary in how much of the work an agent can do. Reading documentation helps it propose an answer. Access to configuration and build tools lets it implement that answer. Debugger access lets it inspect what happened when the code ran. TI and ADI have reached that last step, which gives an agent a way to check its work against the target.

The customer's board adds another requirement. A car door module might combine one vendor's Bluetooth SoC, another's microcontroller, and a third's power management IC. Bringing it up means working across all three, against the customer's schematic and with the probes and instruments on their bench.

Vendor tools are generally centered on their own ecosystems, though some, including Renesas 365, support mixed-vendor systems. Their usefulness still depends on how well they fit into a setup the vendor doesn't control. An engineer needs the agent to work with the repository, toolchain, and board already in front of them.

Firmware can hold up new silicon

Every chip ships with a software product attached, whether or not anyone prices it separately. Before a customer starts building, the vendor's engineers have written peripheral drivers, hardware abstraction layers, board support packages, RTOS ports, example projects, and evaluation kit firmware. Each new variant and toolchain adds implementation and maintenance work.

Software support can lag the silicon, especially for new variants and less common peripherals. The part may be ready while a driver is incomplete, an RTOS port is missing, or the only example targets a different board. If AI shortens chip design cycles, SDK teams will have even less time to close those gaps.

Agents can take on much of the first implementation and test work. Inside an established vendor's repository, the process can look like this:

  1. Read the reference manual, including register maps, the clock tree, and errata.
  2. Draft an implementation plan that cites the source behind each hardware-specific decision. An engineer reviews and corrects it before implementation.
  3. Write the drivers and board support using the vendor's existing build system and conventions.
  4. Build, flash, and test on the target through debug probes and bench instruments.
  5. Attach serial logs, register dumps, and signal captures to the results so an engineer can assess them.

Engineers still decide what gets built, whether the approach is right, and whether the result is ready to ship. They spend less time producing the first implementation and more time reviewing it, improving the architecture, and covering parts that have waited for software support.

Zephyr is a useful example. Supporting a part requires devicetree descriptions, Kconfig, drivers, build integration, and runtime validation on hardware. Much of that work also appears when a customer migrates from FreeRTOS to Zephyr. Better vendor support reduces the work customers have to repeat.

Cheaper switching weakens software lock-in

For many customers, the difficult stretch runs from the evaluation kit to their own board. The dev kit example works. Then they change the pins, add a sensor, or use a different power topology, and the example no longer describes the hardware they need to ship.

Agents can shorten that stretch. Embedder, for example, reads the schematic alongside the datasheet to work out pin muxing, pull-ups, bus addresses, and relevant errata. It works in the customer's existing repository with their compiler, build system, debugger, and RTOS, across hardware from multiple manufacturers.

Migration creates a similar problem. A customer may want the security, networking, or performance of a vendor's next-generation part, but moving the legacy firmware takes time they haven't budgeted. An agent with access to both parts' documentation and the new board can help port the HAL, peripheral code, and RTOS integration.

For the vendor, an easier migration gives the customer a reason to stay for another generation. A difficult one gives them a reason to evaluate alternatives.

The same tools make those alternatives easier to adopt. In the Linux Foundation's Zephyr Turns 10 report, 49% of respondents cited easier hardware portability as one of the biggest impacts of adopting Zephyr. Agents can reduce the remaining work of adapting firmware to another part.

Switching costs have helped vendors retain customers for years. Engineers stay with a family because they know its SDK, configurator, and quirks. As ports become cheaper, that familiarity carries less weight.

We think vendors should respond by making their parts easier to move to. The product engineers judge is the silicon together with the experience of using it. A familiar SDK will offer less protection for a part that takes longer to bring up or performs worse once it runs.

FAEs hold what the datasheet can't

Field application engineers, or FAEs, bring a vendor's knowledge to the customer's bench. They're often among its most experienced engineers, and there are far fewer of them than there are customers. Their time gets allocated accordingly. Large accounts get a named FAE. Smaller teams rely on distributors, forums, and support queues.

Many questions reaching an FAE already have answers in the documentation: a clock that won't lock, a pin mux conflict, a driver returning zeros, an erratum the customer missed. Answering them takes time away from design reviews and problems that require experience with the part.

An agent grounded in the vendor's documentation can handle those questions where they arise, with the relevant section cited. When a problem needs an FAE, it can arrive with the investigation already recorded: serial traces, register dumps, schematic context, and the hypotheses tested on the board. The FAE can use the same tools to reproduce it.

Michael Polanyi's observation that we know more than we can tell applies well here. An agent can use what's written down and what it can measure. An FAE may know which reference design worked in a similar product, which trade-off will cause trouble in production, or when the datasheet is wrong.

That experience is difficult to put into documentation. Handling routine questions with agents gives FAEs more time for the design decisions where it matters.

Evaluations end without anyone deciding to end them

A stalled evaluation can disappear quietly. An engineer stuck for a week may never file a ticket. They switch to another part, and the vendor learns about it months later when the opportunity fails to close.

Losing an evaluation can mean losing years of orders. In the Linux Foundation's Zephyr Turns 10 report, 52% of organizations reported supporting Zephyr-based embedded products for five to ten years or longer. Firmware from one product often becomes the starting point for the next, so an early design win can carry into later designs.

Small teams have little room for a slow bring-up. They may have no named FAE, no slack in the schedule, and a competing evaluation kit that already works. Individually, those teams place small orders. Together, they represent more customers than an FAE team can support by hand, and some grow into larger accounts.

An agent that helps them reach working hardware gives the part a chance to be evaluated on its performance. It also extends useful support to teams the vendor's engineers may never meet.

Vendors should track the time from kit arrival to the first verified peripheral on the customer's own board, by part and customer segment. It gives them an earlier view of bring-up problems than a sales opportunity that goes quiet months later.

Agents could change what vendors build

The immediate opportunity is to make existing chips easier to use. A longer-term possibility is that agents change which hardware vendors can reasonably expect customers to program.

Abstractions hide some of what makes a chip different

A modern automotive or industrial controller has several layers between the application and the hardware: drivers, HALs, configuration tools, and frameworks such as AUTOSAR. Those layers let teams reuse code, integrate components, and maintain systems without programming every device from scratch.

They also limit which hardware features an application can reach easily. A cross-vendor driver API exposes what different parts have in common. A vendor HAL exposes the features its SDK team has implemented. A configuration tool exposes the settings someone added to its interface.

This matters in microcontrollers, where many vendors license the same Arm Cortex-M cores. Much of the difference between parts lies in the peripherals: timers, DMA engines, analog front ends, and crypto blocks. A common interface may leave some of those differences out.

An agent that reads the reference manual and tests on the board could make more of them practical to use. It could configure a DMA chain or a timer's capture modes directly from the register description, then measure whether the result meets the application's requirements.

Teams would still need stable interfaces and maintainable code. Certification would still favor known, reviewed components. But writing and maintaining a part-specific implementation could become cheaper, including when the hardware changes.

That makes documentation and tooling part of whether a feature gets used. A precisely documented peripheral with scriptable tools is easier for an agent to target and test. One described only in a scanned PDF, or missing from the SDK, may remain unused even when it would improve the application.

Designing for the application

Hardware architects already face this constraint. Specialized blocks can improve throughput, power consumption, or timing, but customers need a workable way to use them. A controller might offload network security, packet handling, motor timing, or signal processing. It might divide work among different kinds of cores.

The programming effort grows with the combinations. Which tasks should share a bus? What happens to latency when two accelerators use the same memory? Which core should handle an interrupt when battery life matters more than response time?

The answers depend on the application and may change as the firmware changes. Teams can spend considerable time managing those interactions, or settle for a simpler design that leaves some hardware idle.

An agent could help explore those assignments. Given a workload and a goal, it could propose how to divide tasks among cores and accelerators, run the application, and compare the result against timing captures, current measurements, and trace data. It could repeat that work when the application changes.

If that proves reliable, architects would have more freedom to build specialized hardware without requiring customers to manage every interaction by hand. Vendors would have another way to retain customers: hardware that delivers a measurable advantage and tools that make it accessible.

Start with chips that already ship

Customers already have a smaller version of this problem. Security features go unconfigured. Low-power modes go unused because entering and leaving them correctly takes too much work. Peripherals that could offload the CPU sit idle while the main core runs the operation in a loop.

Agents can help investigate those features on parts customers already own. For a vendor, making better use of existing silicon is a practical place to start, with results that customers can measure before choosing their next part.

The broader architectural argument remains a hypothesis. It depends on agents doing this work reliably enough that engineers can maintain and trust the resulting firmware.

Where this argument breaks down

We expect developer experience to influence more design wins over the next few years. It still has limits.

Documentation can be wrong, and bench tests cover only the conditions tested. An agent can collect evidence faster without settling every question about behavior in production.

Physical validation also takes time. Writing more firmware doesn't eliminate test setup, environmental testing, or the need to investigate intermittent failures.

Experienced engineers remain necessary for undocumented behavior, analog problems, and design decisions that depend on the product's requirements. Safety-critical firmware still requires human review and traceability, regardless of who wrote the first draft.

And price, supply, and long-term availability still decide plenty of designs. No SDK fixes a part you can't buy.

If you build chips, tell us what we got wrong. Bring the part your FAEs get the most tickets about to a working session with our team, and we'll see what an agent can do with it on the bench.

If you write firmware, tell us about your setup: which chips came up quickly with an agent, and which ones you gave up on.

Frequently asked questions

Why is developer experience becoming more important for silicon vendors?

Engineers who use agents in their daily work expect them to help with a new chip too. Documentation the agent can read, tools it can operate, and tests it can run on hardware all affect how quickly a team reaches a working prototype. That can determine whether a part stays under evaluation.

How can AI help a vendor's SDK team?

An agent can draft drivers, board support, and RTOS ports using the part's documentation, then build and test them on the target. Engineers review the implementation and its evidence, giving them more time for architecture and gaps in software coverage.

Does AI replace field application engineers?

Agents can answer documented questions and gather evidence before an escalation. FAEs still handle the work that depends on experience with the part and the customer's design, including problems the documentation doesn't explain.

Why do customers abandon chip evaluations?

Bring-up can consume more time than a team has available. When another part already works on the bench, the team may move on without raising a support ticket. Better documentation, tools, and early help give the original part more time to be judged on its performance.

What makes silicon agent-ready?

Documentation that can be searched and cited, precise hardware descriptions, scriptable configuration and build tools, and access to debugging and hardware tests. Engineers also need examples that work on the supported target and a clear record of what was tested.

How could AI change chip architecture?

Agents could make specialized peripherals and heterogeneous cores easier to use by helping assign work, implement it, and measure the result on the board. If that process becomes reliable, architects could offer hardware features that would otherwise demand too much programming effort.

What hardware and firmware does Embedder support?

Embedder works across MCU and board platforms from multiple manufacturers. It supports C, C++, and Rust in bare-metal and RTOS projects, including FreeRTOS and Zephyr, and teams can add custom hardware with its documentation.

Meet Embedder, your team's
autonomous firmware engineer