From Idea to ESP32 Demo in a Day: How AI Unlocked My Engineering Superpower
Thomas Kunnumpurath
VP Systems Engineering · Solace

Building an IoT demo with an ESP32 and an Arduino camera module used to be a multi-day affair for me. Not because the core logic was inherently complex, but because of the sheer volume of boilerplate, driver quirks, and unfamiliar syntax that comes with embedded systems. Then, a few months ago, I needed a proof-of-concept for an edge analytics pipeline – something that could capture images, run local inference, and publish metadata to a Solace event mesh. I sat down on a Saturday, armed with Claude Code, and watched the impossible happen: a working, end-to-end demo before dinner.
The narrative around AI coding assistants often focuses on code generation, replacing repetitive tasks, or even outright replacing junior developers. But my Saturday ESP32 sprint taught me something far more profound: AI isn’t flattening the engineering landscape; it’s raising the stakes for senior engineers. It compressed my time from idea to working proof, yes, but it dramatically amplified the demand for judgment, robust design, and deep system knowledge. It’s not about typing faster; it’s about thinking clearer.
The Boilerplate Vanishes, The Design Emerges
For that ESP32 demo, my goal was simple yet multifaceted: an edge device that could take a picture, perhaps detect a simple object (like a presence sensor), and then publish an event with the image metadata and detection results to a global Solace Event Mesh. Doing this from scratch means wrestling with C++ for the ESP-IDF framework, configuring Wi-Fi and MQTT clients, setting up camera drivers, and integrating a TinyML model.
Here’s where Claude Code became an absolute force multiplier. I fed it prompts for:
- “C++ code for ESP32-CAM to initialize OV2640 camera.”
- “Example of connecting ESP32 to Wi-Fi and MQTT broker.”
- “Skeleton C++ for publishing a JSON payload over MQTT with image buffer size.”
- “Basic image capture loop, saving to a buffer.”
Within minutes, I had functional, if basic, chunks of code. This wasn’t just generating a single function; it was scaffolding the foundational structure of the embedded application, complete with error handling suggestions and best practices I might have forgotten in the specific context of ESP32. Hours of digging through documentation, Stack Overflow, and example repositories simply vanished.
But the AI didn’t architect the solution. It didn’t decide:
- How the events should be structured to support downstream analytics.
- Which topics to publish to, ensuring dynamic routing and decoupling from consumers.
- Where to run the inference model – directly on the ESP32 (if it fit), or offload it to a more powerful local device like my MacBook via a lightweight API (where I used Workers AI for a quick test).
- How to manage device state and connectivity resilience in a real-world, potentially flaky edge environment.
These were the decisions that demanded my two decades of systems experience. My deep understanding of event-driven architecture, honed from migrating Deutsche Bank from TIBCO to Solace, and my experience running high-throughput systems at Capital One, suddenly became more valuable, not less. The AI handled the what of the code; I handled the why of the system.
Beyond the ESP32: Consistency Across Projects
This pattern wasn’t unique to the ESP32. When I overhauled my personal blog’s publishing pipeline – migrating from Wordpress to a Svelte-powered markdown setup hosted on Cloudflare Pages – AI tools significantly accelerated the scaffolding of SvelteKit components and the initial CI/CD pipeline scripts. Again, the heavy lifting of boilerplate was automated, freeing me to focus on content structure, SEO strategy, and the overall developer experience. The same goes for a local stock screener I’ve been tinkering with; API integrations and initial data parsing were instant, but defining the complex screening logic, optimizing for real-time data feeds, and integrating with external data sources required my full attention to system design and performance considerations.
As a VP, I’ve made it a point to stay hands-on. It’s not just about leadership; it’s about credibility and understanding the real-world friction our engineers face. AI coding tools have fundamentally changed what “hands-on” means for me. It’s no longer about proving I can write boilerplate faster; it’s about leveraging AI to get to the core architectural and design challenges faster. It’s about compressing the distance from idea to meaningful proof.
Your Judgment is the New Premium
The real lesson here isn’t that AI makes coding easy; it’s that AI makes judgment paramount. It liberates senior engineers from the drudgery of boilerplate and debugging obscure syntax, allowing us to spend vastly more time on the truly critical work: system design, architectural tradeoffs, understanding the business domain, and anticipating failure modes. The 80/20 rule of engineering just got a lot more extreme: 80% of the friction (boilerplate, glue code, initial setup) can be handled by AI, but the remaining 20% (design, integration, judgment) now accounts for 80% of the value and requires 100% of your senior expertise.
This isn’t just about personal productivity; it’s about the evolving role of every senior engineer and engineering leader. If you’re not actively experimenting with AI coding tools, you’re missing a critical shift. They are standard tooling now, not a novelty. But more importantly, if you’re not using them to elevate your focus on system knowledge, design principles, and strategic decision-making, you’re missing their true power. AI is a powerful assistant, but it’s not a replacement for the accumulated wisdom of years spent shipping software. It’s a magnifying glass, revealing what always mattered most: the human brain that understands the ‘why’ behind the ‘what,’ and the ‘how’ behind the ‘works.’