Embedded AI Podcast

E15 Julia Imlauer on introducing AI into organizations

We talk with Julia Imlauer, Director for AI Strategy and Development, about the practical realities of introducing Gen AI tools into engineering organizations. Julia shares her experience training engineers and management across multiple companies, revealing what actually works—and what doesn't—when rolling out LLM-based coding assistants. The conversation covers the adoption curve from early enthusiasts to skeptics, the importance of giving engineers dedicated time to experiment, and why "word of mouth" matters more than top-down mandates. We discuss the messy reality of legacy codebases where LLMs shine, the challenge of managing AI-generated code in pull requests, and the emerging cost crisis as providers shift from subsidized to consumption-based pricing. Julia also addresses common fears about junior developer training and the misconception that LLMs can replace human expertise. Key Topics: * [02:30] Julia's background in robotics and machine learning, and how she started introducing Gen AI tools into development workflows * [05:15] Why LLMs help with messy, historically-grown codebases more than pristine template-based workflows * [09:45] Different developer preferences: IDE integration vs. separate LLM interfaces * [13:20] The adoption curve: early adopters, skeptics, and the crucial middle mass that needs convincing * [16:00] Training sessions that work: giving engineers blocked time to experiment, not step-by-step tutorials * [19:30] The power of word-of-mouth and why ambassador programs sometimes help spread adoption * [24:10] Training management and executives: IP protection, managing AI-generated code in pull requests, and supporting skeptical engineers * [29:45] The billing nightmare: token consumption, opacity in pricing models, and the shift away from all-you-can-eat plans * [35:20] Common skeptic concerns: fear of replacement, adoption pain, and outdated first impressions from early LLM versions * [38:50] Junior developer training with LLMs: why pair programming and code reviews still matter more than writing every line by hand * [43:15] Communication breakdowns between departments: translating vocabulary between IT, legal, and engineering * [46:30] Looking ahead: the need for agentic frameworks, standardization, and routing models to manage costs Notable Quotes: "What they do for you is really, they free your engineers to focus on things that matter. They write the boilerplate code. They write the code which you don't want to think about, which is a necessity, which you need to have to make everything work. But it's just like a doing concept." — Julia Imlauer "It sounds stupid when you say you need kind of a education training session for engineers to use this tool, but exactly this is what I experienced—they don't need you know a training in the ways of you need to click here and here and here. What they need is blocked two hours out of their daily coding hustle and really get kind of a free mind to take a look at the tool." — Julia Imlauer "There is this misconception of, okay, we don't need junior developers anymore. They just cost and then an LLM can do that. And let's just pile more on our senior developers. I mean, this is not working. And everyone who is in software development understands that." — Julia Imlauer Resources Mentioned: * Caveman - A GitHub repo that compresses prompts to very basic words to reduce context window size and token consumption * Open Claw / Nemo Claw - Open source agentic framework projects exploring standardized interfaces for LLM agents * MCP (Model Context Protocol) - An emerging standard for LLM tool integration mentioned as a potential path toward provider-agnostic frameworks

E14 Kwabena Ageyman on OpenMV

We sit down with Kwabena Ageyman, co-founder of OpenMV, to explore how microcontrollers have evolved from simple 8-bit chips to AI-capable systems that rival desktop computers. Kwabena walks us through OpenMV's journey from the CMU Cam days to their latest products—the OpenMV Cam AE3 and N6—which pack neural network accelerators, image signal processors, and H.264 encoders into single-chip packages. What makes these systems remarkable isn't just raw performance (250+ gigaops for AI inference), but what they enable: battery-powered computer vision deployments with no infrastructure requirements. Kwabena demonstrates running a complete web server with live video streaming—all in MicroPython on a microcontroller. We discuss the practical implications: doorbell cameras that don't phone home, parking lot monitors that run on solar panels, and industrial vision systems that don't require conduit runs. The conversation touches on hard technical choices (why debayer images even for AI?), the underappreciated value of MicroPython for complex applications, and the infrastructure costs that kill many promising AI deployments. Kwabena also previews what's coming: transformer support on microcontrollers and WiFi HaLow for long-range, high-bandwidth connectivity. For anyone working on edge AI or embedded vision, this episode offers both practical insights and a glimpse of what's possible when hardware acceleration meets thoughtful software design. Key Topics: * [00:03] Introduction to OpenMV and the evolution from "impossible" computer vision on microcontrollers to AI-capable systems * [00:05] Technical specs of the AE3 and N6: 250 gigaops performance, 5-64MB RAM, image signal processors, and H.264 encoding * [00:12] Why image processing steps like debayering matter even for AI applications * [00:18] The infrastructure cost problem: why power, connectivity, and deployment logistics kill many AI projects * [00:28] Running MicroPython on microcontrollers: web servers, RTSP streaming, and complex applications without Linux * [00:35] Live demo: complete web interface with video streaming running on a microcontroller * [00:42] Real-world use cases: YOLO object detection, face tracking, drowsiness detection, and parking lot monitoring * [00:52] The future: transformer support on microcontrollers and WiFi HaLow for long-range connectivity Notable Quotes: "Ten years ago when we started, if you Googled for computer vision on microcontrollers, you got a single Stack Overflow reply about how that was impossible. Since then, a lot has changed." — Kwabena Ageyman "The product dies when you have to tell people: I want you to put 10,000 of these in the field. They look at the infrastructure cost and say, what does that look like end to end? Is that actually going to be a net benefit, or is it just sexy and looks cool?" — Kwabena Ageyman "Having AI on the edge actually unlocks privacy. It is a decision to collect all the data and store it forever. If you have Edge AI locally on these devices, the device manufacturer can say: we're actually not going to go into a format where we have infinite data collection of everything." — Kwabena Ageyman Resources Mentioned: * OpenMV [https://openmv.io] - OpenMV's website with products, documentation, and community resources * Roboflow [https://roboflow.com] - Cloud platform for training computer vision models, partnered with OpenMV * Edge Impulse [https://edgeimpulse.com] - Edge AI development platform, OpenMV partner for model training * WiFi HaLow - Long-range, low-power WiFi technology (up to 10 miles) mentioned for future connectivity * Embedded Online Conference - Conference where Kwabena, Luca, and Ryan will be speaking

E13 Ryan visits Luca (and they talk abut spec-driven development)

For E13 we recorded live in Luca's garden in Munich, with Ryan dropping by ahead of Embedded World week. Ryan and Luca talk about spec-driven development in the AI era: where the discipline came from, what changes when an LLM is doing the typing, and the failure modes that show up over and over again in trainings. The short version: vibe coding will get you something that demos beautifully, but the moment a stranger asks "what does this button do?", it tends to expose how little was actually thought through. The conversation circles around a few recurring themes — the iterative loop you cannot skip even when the AI lets you, the temptation to one-shot whole projects, and the awkward fact that the AI itself seems to actively prefer working in waterfall mode. We also get into why requirements engineering and product ownership matter more (not less) with AI in the picture, why TDD doubles as a way of describing the goal to your assistant, and why the engineer staying in the loop — with that loop running tighter and faster — is what actually makes this work in practice. Plus an honest digression about all the ditches Luca has fallen into building Claude Code skills around his daily workflow. Key Topics: * [02:24] Three artifacts of spec-driven development — and what each one means in the AI era * [05:45] Trainings, vibe-coded games, and the "what does this button do?" moment * [11:27] Long-lived branches, three months of code in an hour, and why both fail for the same reason * [22:25] Beningo's multiplier metaphor: what if the engineer's value is between -1 and 1? * [24:25] Engineering as conversations; curly brackets as a side effect * [27:17] Why requirements engineering and product ownership become more important with AI * [30:59] The AI wants waterfall — and you need to fight it * [33:54] One-shot prompts for whole projects: lying to yourself in five lines * [37:27] Staying in control: one unit of work, AI in the loop, integrate, done * [41:32] Filling ditches one at a time: Luca's Claude Code skills setup * [43:06] TDD as the act of describing the goal — to yourself and to the AI Notable Quotes: "If you've got a five-line prompt that generates 10,000 lines of code for you, then there's just going to be a lot of blank spots in there, a lot of ambiguity in there. That can't be good." — Luca Ingianni "I've had teammates create a long-lived branch and tell me 'I'll see you in a few months.' And I'm like — no. They don't understand how this is going to interact with the rest of the system. And you're basically doing that same thing — writing three months worth of code in an hour. Cool, now what?" — Ryan Torvik "Engineering is what happens when engineers talk to one another, and the differential equations and the C++ code are just side effects of those conversations." — Luca Ingianni Resources Mentioned: * embeddedai.academy [https://embeddedai.academy] — Luca's AI trainings for embedded teams * Agile Embedded Podcast [https://agileembeddedpodcast.com] — sister show, more on agile in the embedded world * Embedded World [https://www.embedded-world.de] — annual embedded systems trade fair in Nuremberg, where Ryan was heading next * Claude Code — the AI coding tool Luca built his "skills" workflow around * Jacob Beningo's "multiplier" framing for AI in development teams (referenced from E12)

E12 Learning AI-powered development with Jacob Beningo

We sit down with Jacob Beningo, a real-time embedded systems consultant with 20 years of experience, to talk about what we've learned teaching engineers to use AI in their development workflows. Turns out, the hard part isn't getting AI to write code—it's all the systems engineering that comes before and after. We discuss common mistakes people make when starting out, like treating AI as a magic code generator instead of a pair programming partner, and why you absolutely cannot skip requirements, architecture, and critical thinking just because the AI can type faster than you. Jacob shares stories from his training sessions, including an AI that refused to follow test-driven development because "that would take too long." We explore why AI actually forces you to become a better engineer by taking away the dopamine hit of typing code yourself, and why IDE plugins might be leading people astray by keeping them at the wrong level of abstraction. The conversation gets real about costs—both in tokens and electricity bills—and why the "set it and forget it" YouTube hype doesn't match reality. If you're skeptical about AI in embedded systems, good—keep that skepticism. You're going to need it. Key Topics: * [03:15] The real challenge: systems engineering, not code generation * [08:45] Why requirements engineering skills matter more than ever with AI * [14:20] The push-button module exercise: spending a full day on design before any code * [16:30] When AI refuses to follow TDD: "That would take too long" * [22:40] The temperature sensor exercise: when tests pass but the code isn't production-ready * [28:15] Code is cheap, but experiments aren't free: finding the balance * [35:50] The hidden costs of AI: token budgets and rising electricity bills * [42:10] Why IDE plugins might be the wrong interface for AI-assisted development * [48:30] Using AI as a pair programming partner, not a code completion tool * [53:20] Keep your skepticism: why critical thinking is more important than ever Notable Quotes: "The AI finished writing the code and all the tests in like four seconds. I'm like, how was that so fast? Well, I just wrote all the code. You didn't follow the TDD process? No, that would take too long." — Jacob Beningo "If you throw in such a vague requirement, the thing can't read their mind and neither can they read its mind. So it's really just a matter of luck what you're going to get." — Luca Ingianni "The AI is the best puppy you'll ever have. It'll go pick up the stick for you. And you're like, no, not that stick. What do you mean not that stick? You didn't tell me which stick. I grabbed you the stick." — Ryan Torvik Resources Mentioned: * Jacob Beningo on LinkedIn [https://www.linkedin.com/in/jacobbeningo] - Daily posts about embedded systems development and modernization * Beningo.com [https://beningo.com] - Jacob's consulting and training services for embedded systems * Embedded Software Academy [https://www.beningo.com/embedded-software-academy/] - Training courses including AI for embedded systems development * Embedded Online Conference [https://embeddedonlineconference.com/] - Annual May conference for embedded systems education and community * Agile Embedded Podcast Slack [https://agileembeddedpodcast.com/] - Community discussion channel mentioned by the hosts

E11 debugging embedded systems using AI

Ryan and Luca explore practical techniques for using AI to debug embedded systems -- from analyzing breadboard photos to parsing UART output and managing complex debugging workflows. LLMs work best as force multipliers rather than replacements for engineering expertise: they handle tedious tasks like adding printf statements, analyzing logs, and decoding resistor color codes, while the engineer guides the process and catches mistakes. A key theme is context management: balancing deterministic scripts for repeatable tasks with non-deterministic AI analysis, and using separate sessions to keep debugging focused. We share cautionary tales of LLMs getting stuck in loops or reverting to common patterns despite specific instructions -- human oversight remains essential. Experienced engineers benefit most because they can effectively steer the LLM and recognize when it goes off track. Key Topics: * [02:30] Debugging hardware via photos -- having LLMs identify wiring errors on breadboards * [06:45] The rubber duck effect -- LLMs as interactive debugging partners * [11:20] Printf debugging with AI -- adding debug statements and analyzing UART output * [15:40] Context management -- separate sessions, distilled datasheet summaries * [22:15] LLM failure modes -- loops, pattern reversion, ignoring specific instructions * [28:30] Force multiplier vs. replacement -- why experience matters more with AI tools * [33:50] Deterministic scripts + non-deterministic AI analysis * [38:20] Future: webcams and oscilloscope screenshots for real-time hardware debugging Notable Quotes: "It's like the over-eager intern -- it's a little naive, but it can type like the devil." -- Luca Ingianni "You cannot use an LLM as a replacement for your brain or for your experience, but you can use it as a force multiplier." -- Luca Ingianni "The LLM does not have that emotional connection to the code. I don't think people understand how emotional that connection is." -- Ryan Torvik Resources Mentioned: * Claude Code (Anthropic) -- AI coding assistant used for debugging, image analysis, and code generation * Arduino/Elegoo Development Boards -- hardware platforms discussed in context of voltage compatibility debugging * Agile Embedded Podcast -- Luca's podcast on agile practices in embedded development