The Pragmatic Embedded Podcast

We're back talking about Test-Driven Development, just 10 episodes after our last TDD discussion. This time, Jeff and Luca tackle the practical challenges that trip up developers trying to adopt TDD - especially that awkward moment staring at a blank screen wondering "what do I even type first?"

Drawing from Luca's experience training embedded developers, we explore why TDD feels so unnatural at first and how to actually get started. We break down the process: from sketching test ideas as bullet points, to writing test outlines in plain English, to finally implementing actual test code. Along the way, we discuss how LLMs change the game - both helping overcome the fear of the empty screen and creating new traps when they generate overwhelming amounts of test code. Whether you're coding by hand or working with AI assistants, the key is maintaining control through deliberate, incremental steps and keeping your focus on module interfaces and test quality over implementation details.

• [02:30] The common struggle: Why developers abandon TDD after trying it once
• [05:15] TDD is not a design methodology - it comes after decomposition
• [08:45] The mental leap: Calling functions that don't exist yet
• [12:00] Starting with test ideas as bullet points, not full test implementations
• [18:30] Two traps: Coding by hand (fear of empty screen) vs. using LLMs (overwhelming output)
• [25:00] Turning test statements into questions for effective coding spikes
• [32:15] Review test code more thoroughly than production code when using LLMs
• [36:00] Connecting TDD to higher-level specs and requirements

"TDD is really just a Jedi mind trick of thinking about your tasks in a different way that makes it easier for you to come to good answers." — Luca Ingianni

"TDD is not how you build the map. It's how you have confidence in a quality implementation and protection against future regressions." — Jeff Gable

"I've gotten into the habit of reviewing my test code more thoroughly than the actual production code when using LLMs. Because the test code really tells me the shape of the production code." — Luca Ingianni

• Luca Ingianni's website - Link site with information about Luca's trainings, coaching, and contact details
• BaseRef - Requirements, test, and documentation management tool for medical device startups founded by Jeff
• Episode 92 - Previous TDD episode discussing test-driven development in the age of AI
• Jacob Beningo's work - Resources on writing simulators and making business logic data-driven rather than hardware-driven
• Agile Embedded Podcast Slack - Community discussion channel where you can reach the hosts and connect with other listeners

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

After five years and 101 episodes, we're doing something we never thought we'd do: renaming the podcast. The Agile Embedded Podcast is now the Pragmatic Embedded Podcast: having the title reflect where we've been heading for quite a while.

Jeff and Luca discuss why the word "agile" has become cringe-worthy, how the podcast has naturally evolved beyond its original scope, and what this means for future episodes. We talk about the reality of AI adoption in embedded development (spoiler: it's not as widespread as you might think), the importance of engineering fundamentals in an AI-assisted world, and why we're excited to explore topics without feeling constrained by our old name. This is still the same podcast you know, just with a name that finally fits what we actually do: exploring pragmatic approaches to building embedded systems.

• [00:00] The big reveal: Agile Embedded becomes Pragmatic Embedded
• [02:30] Why "agile" has become cringe and why the podcast has outgrown its original name
• [04:15] How past episodes like the QP framework discussion already pointed beyond agile
• [06:00] The reality check: AI adoption in embedded development isn't as widespread as the hype suggests
• [09:45] Jeff's perspective: Every developer is becoming a lead developer managing AI-generated code
• [12:30] What's next: More freedom to explore what's actually useful for embedded developers

"I have literally been cringing internally for a long time saying Agile, Agile, Agile. And I'm just really looking forward to broadening the focus and not feeling bad about it." — Jeff

"My customers never buy the curly brackets, do they? There's a lot of good old-fashioned engineering craft that we can talk about and that we'll continue to talk about." — Luca

"Writing curly braces is going the way of being dead. But software engineering fundamentals, essentially, I see the trend... every developer is going to be essentially what is now a lead developer." — Jeff

• Embedded AI Podcast - Luca's other podcast with Ryan Torvik, focused on AI tools in embedded development
• Luca Ingianni's website - Training and consulting on AI and embedded systems
• BaseRef - Jeff's requirements and test management tool for medical device startups
• Agile Embedded Podcast Slack - Community discussion channel where you can reach the hosts and connect with other listeners

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We flip the script for episode 100! Instead of hosting, Luca and Jeff become the guests as Joe Schneider and Jacob Beningo take over the interview chair. We look back at how two consultants from opposite sides of the world accidentally started a podcast, share war stories about the hardest bugs we've ever chased (spoiler: weeks of work for one-line fixes), and discuss why "Agile" might not be the buzzword it once was. The conversation touches on everything from helicopter avionics to the future of AI in embedded systems, plus some honest talk about what keeps us going after five and a half years and 100 episodes.

"No one gives you permission. You're listening to us because we started talking, and maybe some of you found it interesting. But you can put yourself out there, and you learn by speaking." — Jeff Gable

"Testing is like vacuuming. It's only fun if it rattles in the hose. It's just no fun to test a system that has no bugs." — Luca Ingianni

"AI really is the new Agile - the magical fairy dust that you can sprinkle over your team. It'll take a while for people to realize that this is also much harder than it looks." — Luca Ingianni

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

In the third installment of our requirements engineering series, Luca and Jeff shift focus from requirements themselves to the bigger picture: how do you actually turn ideas into working products? We explore the journey from product vision through roadmaps to backlogs, discussing what makes a good roadmap and—perhaps more importantly—the surprisingly common mistakes that even experienced teams make.

We dig into practical challenges like the "progress by PowerPoint" trap (putting milestones like "specification complete" on your roadmap instead of actual value delivery), the dangers of over-committing to dates before you understand the problem space, and why most organizations struggle with prioritization. Luca shares insights from his agile requirements engineering training, including a clever trap he sets for participants around roadmap design. We also tackle the iron triangle of project management and why varying resources is often the least effective lever to pull when a project is running late. Whether you're a product manager, engineering lead, or startup founder, this episode offers a grounded perspective on planning that respects both ambition and reality.

"If somebody has visions they should go see a doctor—but still, you know, it makes sense to have such a thing. A product vision should be nice and compact, like Kennedy's moon landing speech: what we're doing, the timeline, and the value." — Luca Ingianni

"I don't care about the stupid presentation. Show me a product increment. Show me captured value. Then we're talking. Anything else is just smoke and mirrors." — Luca Ingianni

"Plans are useless but planning is indispensable. That process of getting all the key players in the same room and trying to hash out this schedule is where you will uncover the biggest uncertainties and risks." — Jeff Gable

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We talk with Pete Staples, founder of Blue Clover Devices, about the often-overlooked challenge of flashing firmware in production. Pete shares insights from running a contract manufacturing operation in Shenzhen and explains why the handoff from engineering to manufacturing is more like "hucking it over a fence" than a smooth relay race.

We explore the gap between engineers' assumptions about factory capabilities and the dusty reality of production floors. Pete discusses security challenges, the complexity of modern microcontroller programming, and how Blue Clover's Production Line Tool addresses the middle ground between expensive custom automation and ad-hoc bench setups. We also touch on provisioning, calibration workflows, and why the engineer who designs the product must also define how it's tested.

"Engineers assume that the factories are a lot more sophisticated than they really are. In reality, it's a lot more like just hucking it over a fence and just hoping there's somebody there waiting." — Pete Staples

"They show you their pick-and-place machine and 10-zone reflow oven, and you're like, 'wow, these guys are tipped off.' And then rarely do they say, 'oh, and here's where we do firmware flashing.' It's normally another floor of the building, dimly lit, dusty old PCs." — Pete Staples

"The engineer responsible for the product has to not only engineer the product, but how it's tested. They can't just say, 'here's a bunch of design files, build it and let's see what happens.'" — Pete Staples

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

In this second part of our requirements engineering series, Jeff walks us through his preferred process for developing safety-critical products, particularly medical devices. We explore the crucial distinction between prototyping and design-controlled development, discussing when to start formal requirements work and how to keep your first version minimal yet complete.

Jeff emphasizes the importance of deeply fleshing out requirements before implementation—including error handling, which often comprises 70% of a product. We discuss tracer bullets as a development strategy, the value of writing test cases alongside requirements, and why tracking requirements completion gives you honest project status. Luca and Jeff also debate the finer points of MVPs versus prototypes, and Jeff announces his upcoming requirements management tool for medical device startups.

"Error handling is 70% of your product, if not more. If you only do the 30% of the requirements for the happy path, you're fooling yourself." — Jeff

"If you don't get this right at the outset, it will haunt you through the entirety of your product development process." — Luca

"Paper is the best place to figure it out. Actually think through the requirements rigorously before you start building." — Jeff

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We sit down with Paul Butcher, Unit Director of Dynamic Analysis at AdaCore, to explore verification techniques beyond basic compliance in safety-critical software. Paul shares his experience from Eurofighter to automated trains, explaining how dynamic analysis—from unit testing to coverage analysis to fuzzing—helps find bugs that traditional testing misses.

The conversation dives deep into fuzzing: how it works, why it's so effective at finding corner-case bugs (even in well-tested systems), and the challenges of applying it to embedded systems with timing constraints. Paul introduces an intriguing approach that combines static analysis with targeted fuzzing to automatically triage false positives and generate reproducers. We also touch on formal verification, the role of LLMs in verification workflows, and why the simplest software is often the safest. Whether you're working in aerospace, medical devices, or any safety-critical domain, this episode offers practical insights into building more robust systems.

"Software testing is typically about, is it functionally correct? Fuzzing is like a negative testing technique. It's the inverse of that. It fires random inputs into your system with the intent of finding anomalies." — Paul Butcher

"Every time I speak to someone who's tried fuzzing, even if it's a system that's considered high integrity with a high level of assurance, they always find something. It's really good at eking out those weird corner case scenarios." — Paul Butcher

"With testing you would like to prove the absence of bugs, but unfortunately you can't. So you have to settle for a very distant second place of proving the presence of bugs." — Luca Ingianni

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We sit down with Mohammed Billoo, founder of Mab Labs and author of the Embedded Linux Essentials Handbook, to explore the world of embedded Linux profiling and optimization. Mohammed shares hard-won lessons from the field, including debugging a scientific instrument that mysteriously crashed after 60-minute runs and optimizing a sophisticated MANET platform that took a 20% throughput hit.

The conversation reveals a fundamental truth: in embedded Linux, the CPU is rarely the bottleneck. Mohammed walks us through his systematic approach to performance problems, starting with simple tools like HTOP before diving into specialized instrumentation. We discuss the critical difference between VM size and VM RSS for memory analysis, why dumping console output can kill boot times, and how to leverage kernel configurations for maximum diagnostic bang-for-buck. Mohammed emphasizes the importance of building instrumentation into systems from day one—not for premature optimization, but to give your future self the data needed when problems inevitably surface. The discussion also touches on how LLMs can accelerate the learning curve for complex tools like Valgrind and perf, while stressing that physical reality remains the ultimate arbiter of system performance.

"When you first get started, you have generally this arrogance that like, oh, it works fine. I've tested it. It's good to go. But then as you get more experience, as you become a more senior-level engineer, that arrogance, you start to kind of strip away a lot of that arrogance. You get humbled pretty quickly." — Mohammed Billoo

"The CPU is very rarely the bottleneck because it's meant to, and the drivers are implemented in Linux in such a way that they're intelligent enough that they can hand off a lot of the things of the CPU to coprocessors so that the CPU is really idle." — Mohammed Billoo

"I don't convince myself of a claim that I'm making until I have data to back it up. So I don't say, oh, you know, this is working fine. Like, well, again, what does fine mean? Or, you know, what does well mean? And what is the data to prove that?" — Mohammed Billoo

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We kick off a multi-part series on requirements engineering by exploring what requirements actually are and why they matter - even for Agilists. Jeff shares his medical device expertise while Luca brings his automotive and aerospace background to discuss the different levels of requirements (from high-level user needs to testable system requirements), the importance of traceability, and why proper tooling beats Word and Excel every time.

We dig into practical aspects like the EARS format for writing requirements, the crucial distinction between requirements and design choices, and why glossaries aren't as boring as they sound. Along the way, we tackle the tension between regulatory compliance and actual engineering value, emphasizing that documentation should be an artifact of diligent work - not the work itself. Whether you're in safety-critical industries or just want to build better products, understanding requirements engineering helps manage complexity and prevent costly mistakes.

"The whole agile movement was a reaction to the one time through the requirements specification build test loop that took several years. By the time you got to the end, the requirements no longer applied." — Jeff

"Do not use an LLM to manage requirements. Do use the LLM to write tools that help you manage requirements." — Luca

"I view any medical device that I work on as if it's going to be used on my child. What do I need to do to convince myself that it is safe and effective? Once I have done that, if there are remaining boxes to check to get it through FDA, I will check those boxes." — Jeff

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/

We talk with Tobias Kästner, a physicist-turned-software-architect and technical consultant at Inovex, about his journey from painfully slow hardware-software integration cycles to achieving three-week hardware sprints. Tobias shares hard-won lessons from medical device development, where fuzzy requirements and constant feedback from life scientists forced his team to rethink traditional approaches.

The conversation centers on practical techniques: breaking monolithic PCB designs into modular "feature boards" connected via shields (think Arduino-style), using Git for hardware version control with SHA-1s printed on silkscreens, and leveraging tools like Zephyr RTOS to enable plug-and-play firmware that matches the modularity of the hardware. Tobias explains how relaxing constraints like board size and using automation to merge schematics allowed his team to iterate rapidly while maintaining a clear path to final form-factor designs. We discuss how this approach scaled to projects with 120+ people across multiple teams, and why the interplay between system architecture, organizational structure, and information flow matters more than most realize.

"When the board arrived, not a single line of code had been written for it because no one had been able to touch it. It took us nine additional months to debug all the things out of it." — Tobias Kästner

"I've never seen any board working the first time. I've never seen any prototype without thin wires patching things out, but that's maybe a different story." — Tobias Kästner

"We cannot think these architectures as independent of one another. If we have limitations in two of these architectures, we will see these limitations in the third architecture as well." — Tobias Kästner

Through Inovex, Tobias provides trainings for both Zephyr and Yocto Linux, as well as consultancy and engineering support for embedded projects -- from 1-2 day workshops evaluating architectural state and cost/benefit analysis, to first prototypes, to full-fledged software development. With partners such as alpha-board (Berlin) and Blunk electronic (Erfurt), they also offer agile hardware services and help teams get started with the methods discussed in this episode.

Companies:

Talks and publications:

Books recommended by Tobias:

You can find Jeff at https://jeffgable.com.
You can find Luca at https://luca.engineer.

Want to join the Pragmatic Embedded Slack? Click here

Are you looking for embedded-focused trainings? Head to https://agileembedded.academy/
Ryan Torvik and Luca have started the Embedded AI podcast, check it out at https://embeddedaipodcast.com/