
Insights from recent episode analysis
Audience Interest
Podcast Focus
Publishing Consistency
Platform Reach
Insights are generated by CastFox AI using publicly available data, episode content, and proprietary models.
Most discussed topics
Brands & references
Total monthly reach
Estimated from 2 chart positions in 2 markets.
By chart position
- 🇪🇸ES · Technology#1381K to 10K
- 🇫🇮FI · Technology#104500 to 3K
- Per-Episode Audience
Est. listeners per new episode within ~30 days
750 to 6.5K🎙 ~2x weekly·97 episodes·Last published 2w ago - Monthly Reach
Unique listeners across all episodes (30 days)
1.5K to 13K🇪🇸77%🇫🇮23% - Active Followers
Loyal subscribers who consistently listen
600 to 5.2K
Market Insights
Platform Distribution
Reach across major podcast platforms, updated hourly
Total Followers
—
Total Plays
—
Total Reviews
—
* Data sourced directly from platform APIs and aggregated hourly across all major podcast directories.
On the show
From 14 epsHosts
Recent guests
Recent episodes
Factory Firmware Flashing with Pete Staples
Jun 9, 2026
50m 42s
Requirements Engineering, part 2: A Practical Process for Safety-Critical Development
May 27, 2026
50m 06s
Fuzzing and Dynamic Analysis for High-Integrity Software with Paul Butcher
May 13, 2026
48m 39s
Linux Profiling with Mohammed Billoo
Apr 30, 2026
46m 12s
E94 Requirements Engineering, part 1: Fundamentals
Apr 15, 2026
47m 18s
Social Links & Contact
Official channels & resources
Official Website
Login
RSS Feed
Login
| Date | Episode | Topics | Guests | Brands | Places | Keywords | Sponsor | Length | |
|---|---|---|---|---|---|---|---|---|---|
| 6/9/26 | ![]() Factory Firmware Flashing with Pete Staples✨ | firmware flashingmanufacturing challenges+3 | Pete Staples | Blue Clover Devices | Shenzhen | firmwareproduction+5 | — | 50m 42s | |
| 5/27/26 | ![]() Requirements Engineering, part 2: A Practical Process for Safety-Critical Development✨ | requirements engineeringsafety-critical development+5 | Jeff | requirements management toolmedical devices | — | requirements engineeringsafety-critical+6 | — | 50m 06s | |
| 5/13/26 | ![]() Fuzzing and Dynamic Analysis for High-Integrity Software with Paul Butcher✨ | fuzzingdynamic analysis+4 | Paul Butcher | AdaCoreEurofighter | — | dynamic analysisfuzzing+5 | — | 48m 39s | |
| 4/30/26 | ![]() Linux Profiling with Mohammed Billoo✨ | embedded Linuxprofiling+5 | Mohammed Billoo | Mab LabsEmbedded Linux Essentials Handbook | — | Linux profilingperformance optimization+7 | — | 46m 12s | |
| 4/15/26 | ![]() E94 Requirements Engineering, part 1: Fundamentals✨ | requirements engineeringAgile methodology+5 | Jeff | medical deviceautomotive+4 | — | requirementsAgilists+7 | — | 47m 18s | |
| 4/1/26 | ![]() Hardware-Software Co-Development with Tobias Kästner✨ | hardware-software integrationmedical device development+3 | Tobias Kästner | Inovex | — | hardware-software co-developmentagile sprints+3 | — | 52m 51s | |
| 3/18/26 | ![]() Test-Driven Development in the Age of AI✨ | Test-Driven DevelopmentAI coding tools+3 | — | Claude Code | — | test-driven developmentAI+4 | — | 42m 16s | |
| 3/4/26 | ![]() Engineering Organizations Part 2: Product Companies and Market-Driven Focus✨ | engineering organizationsproduct-market fit+4 | — | product companiesstartups+1 | — | engineering organizationsproduct companies+5 | — | 43m 43s | |
| 2/18/26 | ![]() Engineering Organizations Pt 1: Service Firms - When You Are the Product✨ | engineering organizationsservice firms+4 | — | service-oriented engineering organizationsproduct development firms+1 | — | engineering organizationsservice firms+3 | — | 43m 25s | |
| 1/19/26 | ![]() Rust with Milica Kostic✨ | embedded developmentRust programming+3 | Milica Kostic | embedded LinuxRust+1 | — | Rustembedded software+3 | — | 35m 43s | |
Want analysis for the episodes below?Free for Pro Submit a request, we'll have your selected episodes analyzed within an hour. Free, at no cost to you, for Pro users. | |||||||||
| 1/5/26 | ![]() MicroPython with Matt Trentini✨ | MicroPythonembedded development+4 | Matt Trentini | MicroPythonPlanet Innovation+1 | — | MicroPythonembedded development+4 | — | 57m 43s | |
| 12/16/25 | ![]() Terrible Habits of the Solo Developer✨ | solo developmentembedded systems+3 | — | — | — | solo developerembedded development+3 | — | 53m 46s | |
| 12/3/25 | ![]() Agile Hardware Development with Gregor Gross✨ | agile developmenthardware development+3 | Gregor Gross | Alpha-board | BerlinGermany | agile principleshardware projects+3 | — | 50m 15s | |
| 11/18/25 | ![]() Crossover with Embedded AI Podcast✨ | AI-powered development toolsagile embedded systems engineering+5 | Ryan Torvik | Embedded AI Podcast | — | AIembedded systems+5 | — | 55m 02s | |
| 11/12/25 | ![]() AI-enhanced Embedded Development (May 2025 Edition) | In this episode, Jeff interviews Luca about his intensive experience presenting at five conferences in two and a half days, including the Embedded Online Conference and a German conference where he delivered a keynote on AI-enhanced software development. Luca shares practical insights from running an LLM-only hackathon where participants were prohibited from manually writing any code that entered version control—forcing them to rely entirely on AI tools.The conversation explores technical challenges in AI-assisted embedded development, particularly the importance of context management when working with LLMs. Luca reveals that effective AI-assisted coding requires treating prompts like code itself—version controlling them, refining them iteratively, and building project-specific prompt libraries. He discusses the economics of LLM-based development (approximately one cent per line of code), the dramatic tightening of feedback loops from days to minutes, and how this fundamentally changes agile workflows for embedded teams.The episode concludes with a discussion about the evolving role of embedded developers—from code writers to AI supervisors and eventually to product owners with deep technical skills. Luca and Jeff address concerns about maintaining core software engineering competencies while embracing these powerful new tools, emphasizing that understanding the craft remains essential even as the tools evolve.Key Topics[02:15] LLM-only hackathon constraints: No human-written code in version control[04:30] Context management as the critical skill for effective LLM-assisted development[08:45] Explicit context control: Files, directories, API documentation, and web content integration[11:20] LLM hallucinations: When AI invents file contents and generates diffs against phantom code[13:00] Economics of AI-assisted coding: Approximately $0.01 per line of code[15:30] Tightening feedback loops: From day-long iterations to minutes in agile embedded workflows[17:45] Rapid technical debt accumulation: How LLMs can create problems faster than humans notice[19:30] The essential role of comprehensive testing in AI-assisted development workflows[22:00] Challenges with TDD and LLMs: Getting AI to take small steps and wait for feedback[26:15] Treating prompts like code: Version control, libraries, and project-specific prompt management[29:40] External context management: Coding style guides, plan files, and todo.txt workflows[32:00] LLM attention patterns: Beginning and end of context receive more focus than middle content[34:30] The evolving developer role: From coder to prompt engineer to AI supervisor to technical product owner[38:00] Code wireframing: Rapid prototyping for embedded systems using AI-generated implementations[40:15] Maintaining software engineering skills in the age of AI: The importance of manual practice[43:00] Software engineering vs. software carpentry: Architecture and goals over syntax and implementationNotable Quotes"One of the hardest things to get an LLM to do is nothing. Sometimes I just want to brainstorm with it and say, let's look at the code base, let's figure out how we're going to tackle this next piece of functionality. And then it says, 'Yeah, I think we should do it like this. You know what? I'm going to do it right now.' And it's so terrible. Stop. You didn't even wait for me to weigh in." — Luca Ingianni"LLMs making everything faster also means they can create technical debt at a spectacular rate. And it gets a little worse because if you're not paying close attention and if you're not disciplined, then it kind of passes you by at first. It generates code and the code kind of looks fine. And you say, yeah, let's keep going. And then you notice that actually it's quite terrible." — Luca Ingianni"I would not trust myself to review an LLM's code and be able to spot all of the little subtleties that it gets wrong. But if I at least have tests that express my goals and maybe also my worries in terms of robustness, then I can feel a lot safer to iterate very quickly within those guardrails." — Luca Ingianni"Roughly speaking, the way I was using the tool, I was spending about a cent per line. Which is about two orders of magnitude below what a human programmer roughly costs. It really is a fraction. So that's nice because it makes certain things approachable. It changes certain build versus buy decisions." — Luca Ingianni"You can tighten your feedback loops to an absurd degree. Maybe before, if you had a really tight feedback loop between a product owner and a developer, it was maybe a day long. And now it can be minutes or quarters of an hour. It is so much faster. And that's not just a quantitative step. It's also a qualitative step." — Luca Ingianni"Some of my best performing prompts came from a place of desperation where one of my prompts is literally 'wait wait wait you didn't do what we agreed you would do you did not read the files carefully.' And I'd like to use this prompt now, even before it did something wrong. And then it apologizes as the first step. And I feel terrible because I hurt the LLM's feelings. But it is very effective." — Luca Ingianni"As you tighten your feedback loops, quality must be maintained through code review and tests. Test first, new feature, review, passing tests—you need to go through that red-green-refactor loop. You can just hopefully do it much more quickly, and maybe in slightly bigger steps than you did before manually." — Jeff Gable"A lot of what I'm doing is really intended to rein in an LLM's propensity to sort of ramble. It's very hard to get them to practice TDD because you can ask them to write the test first, then they will. And then they will just trample on and write the implementation right with it without stopping and returning control back to you." — Luca Ingianni"Those prompts tend to be to some degree specific to the particular code base or the particular problem domain. Every now and then you stumble across ways of making an LLM do exactly what you want it to do within the context of the particular code base. And once you find a nugget like this, you keep it. You don't just keep it in the generic library. Some of those tricks will be very specific to a particular code base." — Luca Ingianni"Just like humans, LLMs tend to pay more attention to the stuff at the beginning of the context and at the end, and the middle sort of gets not quite forgotten but kind of fuzzy. You really need to have a way to extract all of that before it becomes fuzzy and store it in a safe place where it can't be damaged, like a file." — Luca Ingianni"I think we will hit this weird valley in the coming five years where everyone's just using LLMs and no one knows how to write code anymore. And there will be a need for people who can leverage the tools, but still have the skills that serve as the solid foundation." — Jeff Gable"Maybe this is essentially software engineering finally becoming true to its name. At the moment, software engineering is sort of more like software carpentry. You're really doing the craft. You're laboring to put the curly brackets at the right places. And maybe now it's more about taking a step back and thinking in terms of architecture, and thinking in terms of goals, as opposed to knowing how to swing a hammer." — Luca IngianniResources MentionedEmbedded Online Conference - Premier online conference for embedded systems professionals featuring talks on AI integration, development practices, and cutting-edge embedded technologies. All sessions are recorded and available for on-demand viewing.Aider - AI pair programming tool mentioned for its ability to integrate web content into context using commands like '/web [URL]' to incorporate API documentation and other online resources directly into the development workflow.GitHub Copilot - AI-powered code completion tool integrated with VS Code and other IDEs, enabling context-aware code generation and assistance for embedded development workflows. You can find Jeff at https://jeffgable.com.You can find Luca at https://luca.engineer.Want to join the agile Embedded Slack? Click hereAre 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/ | — | ||||||
| 11/9/25 | ![]() Zephyr with Luka Mustafa | Zephyr RTOS: Modern Embedded Development with Hardware Abstraction and Community-Driven Best Practices In this comprehensive episode, Luka Mustafa, founder and CEO of Irnas Product Development, provides an in-depth exploration of Zephyr RTOS and its transformative impact on embedded development. We dive deep into how Zephyr's Linux Foundation-backed ecosystem enables hardware-agnostic development, dramatically reducing the time spent on foundational code versus business-value features. Luka shares practical insights from five years of specializing in Zephyr development, demonstrating how projects can achieve remarkable portability - including running the same Bluetooth code on different chip architectures in just an hour, and even executing embedded applications natively on Linux for development purposes. The discussion covers Zephyr's comprehensive testing framework (Twister), CI/CD integration capabilities, and the cultural shift required when moving from traditional bare-metal development to this modern RTOS approach. We explore real-world applications from low-power IoT devices consuming just 5 microamps to complex multi-core systems, while addressing the learning curve challenges and when Zephyr might not be the right choice. This episode is essential listening for embedded teams considering modernizing their development practices and leveraging community-driven software ecosystems. ## Key Topics * [03:15] Zephyr RTOS fundamentals and Linux Foundation ecosystem benefits * [08:30] Hardware abstraction and device tree implementation for portable embedded code * [12:45] Nordic Semiconductor strategic partnership and silicon vendor support landscape * [18:20] Native POSIX development capabilities and cross-platform debugging strategies * [25:10] Learning curve challenges: EE vs CS background adaptation to Zephyr development * [32:40] Resource requirements and low-power implementation on constrained microcontrollers * [38:15] Multi-vendor chip support: STMicroelectronics, NXP, and industry adoption trends * [42:30] Safety-critical applications and ongoing certification processes * [45:50] Organizational transformation strategies and cultural adaptation challenges * [52:20] Zbus inter-process communication and modular development architecture * [58:45] Twister testing framework and comprehensive CI/CD pipeline integration * [65:30] Sample-driven development methodology and long-lived characterization tests * [72:15] Production testing automation and shell interface utilization * [78:40] Model-based development integration and requirements traceability * [82:10] When not to use Zephyr: Arduino simplicity vs RTOS complexity trade-offs ## Notable Quotes > "With Zephyr, porting a Bluetooth project from one chip architecture to another took an hour for an intern, compared to what would traditionally be months of effort." — Luka Mustafa > "How many times have you written a logging subsystem? If the answer is more than zero, then it shouldn't be the case. Someone needs to write it once, and every three years someone needs to rewrite it with a better idea." — Luka Mustafa > "The real benefit comes from doing things the Zephyr way in Zephyr, because then you are adopting all of the best practices of developing the code, using all of the subsystems to the maximum extent." — Luka Mustafa > "You want to make sure your team is spending time on things that make money for you, not on writing logging, for example." — Luka Mustafa | — | ||||||
| 10/21/25 | ![]() Crossover with Mob Mentailty Part 2 | In this deep-dive continuation with Mob Mentality Show hosts Austin Chadwick and Chris Lucian, we explore the practical implementation of mob programming in embedded and IoT environments. The discussion covers how collaborative programming extends beyond pure software development to include firmware engineers, hardware teams, and DevOps specialists working together in real-time. Key insights include strategies for managing cross-disciplinary collaboration, overcoming organizational resistance, and maintaining continuous delivery pipelines in hardware-constrained environments. The conversation reveals how mob programming can dramatically reduce feedback loops and eliminate the traditional handoff delays between embedded system components, leading to multiple daily production deployments even in IoT contexts."+y | — | ||||||
| 10/16/25 | ![]() Crossover with Mob Mentality part 1 | In this special crossover episode with the Mob Mentality Show, Jeff and Luca explore how mob programming can revolutionize embedded systems development. The discussion covers critical pain points in the embedded industry, including hardware-software coupling, documentation overhead in safety-critical systems, and the persistent silos between electrical, mechanical, and software engineers. Chris Lucian and Austin Chadwick from the Mob Mentality Show share practical strategies for implementing collaborative development practices, including hardware abstraction layers, the inverse Conway maneuver, and techniques for breaking down organizational barriers. The conversation provides actionable insights for embedded teams looking to improve flow efficiency, reduce cycle times, and enhance cross-functional collaboration in IoT and hardware product development. | — | ||||||
| 7/8/25 | ![]() Violet Su on hardware manufacturing | In this episode of the Agile Embedded Podcast, Luca speaks with Violet Su, Business Development Manager at Seed Studio, about the challenges and opportunities in hardware manufacturing. Violet shares insights on how Seed Studio has evolved to become an AI hardware partner, providing everything from sensors to edge computing products and customization services. The conversation explores the realities of hardware development, from initial prototyping to mass production. Violet emphasizes the importance of getting products into users' hands quickly to gather feedback, even if they're not perfect. She highlights common pitfalls for newcomers to hardware manufacturing, including underestimating costs, certification requirements, and supply chain complexities. The discussion also covers the growing influence of AI in hardware development and how emerging connectivity technologies are shaping the future of embedded systems. | — | ||||||
| 6/25/25 | ![]() AI-augmented software development | Luca and Jeff dive into how AI tools can supercharge embedded development workflows. Luca shares his extensive hands-on experience, while Jeff brings a fresh perspective as someone just starting to incorporate these tools. They explore how AI can help with coding, testing, and debugging - while emphasizing that good software engineering judgment remains crucial. The conversation is particularly timely since AI tools are evolving rapidly, unlike their usually more "evergreen" podcast topics. | — | ||||||
| 4/24/25 | ![]() BONUS: Listener Question on Repository Organization | In this bonus episode, Luca responds to a thoughtful listener question about repository granularity in embedded development projects, particularly in safety-critical industries. The listener describes their approach of using separate repositories for different work products and even considers micro-repositories for different code components. Luca shares his perspective on why this approach makes him uneasy, suggesting it might overcomplicate development processes. He advocates for fewer repositories - ideally a monorepo approach - and explains how configuration management can be handled effectively within a single repository using feature flags, tagging, and CI pipelines. Luca reflects on how his own thinking about repository strategy has evolved over the course of the podcast, moving away from branch-based development toward trunk-based development with appropriate safeguards. | — | ||||||
| 4/23/25 | ![]() MinimumCD | The episode discusses the concept of Minimum Viable Continuous Delivery (Minimum CD), which represents a counter-movement to heavyweight frameworks like SAFe. The hosts explore how Minimum CD provides a set of essential practices for successfully building software-based products without unnecessary complexity. The approach focuses on core principles rather than rigid frameworks, making it particularly relevant for embedded systems development. The discussion covers the fundamental requirements for continuous delivery, including automated testing, pipeline-driven deployments, and trunk-based development. The hosts emphasize that while these practices may seem challenging for embedded systems, they become increasingly important as devices become more sophisticated and connected. A key theme throughout the episode is the importance of building trust in the development process through automation, consistent practices, and cultural commitment. The hosts stress that while some practices may seem difficult to implement in embedded systems, the more challenging they are, the more valuable they become when successfully implemented. | — | ||||||
| 4/9/25 | ![]() Offensive Cybersecurity with Ryan Torvik | In this episode of Agile Embedded, Jeff Gable and Luca Ingianni speak with Ryan Torvik, founder and CEO of Tulip Tree Technology, about cybersecurity from a Red Team hacker perspective. Ryan shares his experience as a former defense contractor supporting offensive cyber operations for the U.S. government and how he's now applying those lessons to the commercial space. Ryan provides fascinating insights into the mindset and challenges of offensive cybersecurity work, explaining how vulnerability researchers approach embedded systems to find exploitable weaknesses. The conversation covers practical security considerations for embedded developers, including the importance of secure coding practices, proper handling of user inputs, and designing security into products from the beginning rather than as an afterthought. Ryan also discusses how emulation technology can help developers test their firmware for vulnerabilities without physical hardware. The episode highlights the growing importance of cybersecurity in embedded systems, particularly in regulated industries like medical devices, and offers practical advice for developers looking to improve their security posture without necessarily becoming security experts themselves. | — | ||||||
| 3/26/25 | ![]() BDD with Steve Branam | # Mastering Behavior-Driven Development in Embedded Systems with Steve Branam In this insightful episode of the Agile Embedded Podcast, Jeff and Luca welcome Steve Branam, a software developer with over 40 years of experience in communication systems, consumer products, and embedded systems. Steve shares his expertise on Behavior-Driven Development (BDD), explaining how it adds an additional layer of discipline on top of Test-Driven Development (TDD) to help developers avoid common pitfalls. Steve describes BDD as a design technique that focuses on behavior rather than implementation details, which helps create more robust, less brittle test suites. He explains how the structured 'Given-When-Then' format forces developers to think about the public API and observable behaviors rather than internal implementation details. Throughout the conversation, Steve provides practical examples of applying BDD to embedded systems, including strategies for testing hardware interactions using test doubles like spies, and approaches for testing state machines without creating brittle tests. | — | ||||||
| 3/5/25 | ![]() John Taylor on the Embedded Systems Cookbook | John Taylor returns to the podcast to discuss his new book "The Embedded Project Cookbook", co-authored with Wayne Taylor. The book serves as a practical guide for embedded systems development, providing recipes and techniques that John has refined over his 30+ year career. Unlike his previous book "Patterns in the Machine" which focused on software engineering best practices, this new book takes a more hands-on approach to project mechanics - from requirements gathering through release. The book provides opinionated guidance on setting up project infrastructure, managing requirements, software architecture, and release processes. While organized in a waterfall-like structure for clarity, it emphasizes the need for agility in embedded development. A key theme is establishing good practices early to make releases boring and predictable rather than chaotic. | — | ||||||
Showing 25 of 101
Pitch Fit is a Pro feature
See how bookable this show is for guests, which brands already advertise, the per-episode ad value, and the best-fit guest and sponsor profile. The numbers are blurred on the free plan.
How readily this show books outside guests like you.
How proven this show is for host-read sponsorships.
For Guests
ProFor Advertisers
ProUpgrade to Pro to unlock guest cadence, sponsor categories, fit scores, and per-episode ad value for this show.
Chart Positions
2 placements across 2 markets.
Chart Positions
2 placements across 2 markets.
