The Watchtower Brief · CraftifAI Series · IoT
An IoT program almost never ships one device. It ships a family — across microcontrollers, radios, sensors, and form factors — and the firmware has to follow every one of them. That is where the economics of IoT quietly break.
The headline cost in connected products is rarely the silicon; it is the engineering required to make each variant work and keep working. And almost all of that engineering lives in firmware that does not travel between targets.
Pick a microcontroller and you have picked an entire world: ESP32, STM32, Nordic, the growing field of RISC-V parts — each with its own:
A product line that spans three or four MCUs — for cost, supply, or feature reasons — is really three or four firmware efforts wearing one product name. The behavior is meant to be identical. The code underneath is anything but.
In principle, moving a device from one MCU to another is a port. In practice it is a rewrite of the parts that matter most:
Every new MCU in the family resets much of this work. The result is that firmware cost scales with the number of targets, not with the product's complexity — which is exactly the opposite of where the margin needs to be. In IoT, the margin lives in firmware cost across the fleet. A product line that spans four MCUs should not cost four times the firmware effort — but today it usually does.
A copilot does not know your board. Ask it for an I²C driver, and it will produce something generic — not firmware that is correct for your part’s register map, your peripheral wiring, and your power budget. As we argued in Why Copilots Don’t Work for Embedded Systems, generic suggestions are the easy part. Target-aware, hardware-optimized firmware is the part that ships — and the part a copilot cannot reach.
The alternative is to describe the device once and generate the firmware for each target from that single source of intent. Define:
…and have hardware-optimized firmware generated for that part: HAL and drivers, peripheral initialization, power management, and test firmware to validate it. When the family adds a fifth MCU, you regenerate from the same spec rather than starting a fifth project.
CraftifAI is built precisely for this. Its firmware generation is aimed at IoT devices and microcontrollers — supporting parts like ESP32 and STM32 today, with a clear direction toward becoming hardware-agnostic and generating portable, universal code across silicon. Early results indicate roughly an 80% reduction in the developer effort the MCU maze normally demands. The shift is from writing device firmware by hand, per part, to generating it from one spec across the whole family — and regenerating it as parts change, supply shifts, or features evolve.
IoT has always been a volume-and-margin game, and firmware has always been the hidden line item that eats both. A team that can hold one specification and emit correct firmware for every MCU in its lineup changes that equation. New variants stop being projects and become regenerations. Engineers stop re-implementing the same HAL for the fourth time and spend their time on what the product actually does.
For years, scaling an IoT line meant scaling the firmware team alongside it. That link is what breaks when firmware becomes something you generate from intent rather than rewrite per part. One spec, every MCU — and the cost of the next device in the family approaches the cost of asking for it.