When we first started building the firmware for Frixos (and this was way back in 2020), Arduino felt like the natural choice. It was quick to get going, had lots of libraries, and frankly, it let us see progress fast—which is a huge morale booster when you’re trying to validate hardware and just get something blinking.
But fast-forward to late 2024, and things started to break. The new ESP core 3.x came out, and with it, a wave of compatibility issues. Some of the libraries we depended on were no longer maintained. Some just didn’t work right. And compile times? A total drag. Every change required a full rebuild. No incremental make. No caching. Just hit compile, then grab a coffee. Maybe lunch.
We were also using AutoConnect, which had been a lifesaver early on. It made it easy to bring up a captive portal and manage WiFi provisioning. But customizing the UI? That’s where it hit a wall. We wanted a better experience for users, and we wanted more control over how our settings pages looked and behaved.
Design Goals for the Rewrite
With all that in mind, we set out with two major goals:
Streamline the firmware – trim the fat, get rid of bloated dependencies.
Build a better user interface – something clean, modern, and actually nice to use.
Oh, and one more thing: I no longer work alone.
Supercharged Development with AI Assistants
We experimented with both Trae and Cursor—both tools that wrap a powerful code assistant into a dev environment, and both with great support for ESP-IDF. It was a game-changer. Productivity went through the roof. These tools don’t just autocomplete—they understand your codebase, suggest improvements, and even generate entire modules if you describe what you need.
We also made some key substitutions:
Replaced TFT_eSPI with LVGL for a much more capable and customizable UI.
Dropped AutoConnect in favor of our own provisioning logic.
And yes, we wrote a lot of new stuff—but we weren’t starting from scratch.
What Worked
1. The UI Workflow Got a Whole Lot Better
I’ve always dreaded writing HTML and JavaScript. Want to add a new setting? That used to mean: edit the HTML, tweak the JS, wire up the APIs for getting and setting data, and hope you didn’t forget a step.
Now? I just describe what I want in natural language, and let AI generate the full UI code. Ten seconds later, it’s in my project and working. It’s like magic.

New UI for firmware 2.0, mostly AI coded
Only took a prompt to add a dark mode, and have the setting stored in NVS.
2. ESP-IDF Isn’t Easy—but It’s Worth It
Yes, ESP-IDF has a steeper learning curve. It’s more “bare-metal,” more configuration-heavy, and you really need to understand how your system ticks. But once you do? It’s solid. It gives you all the tools you need to make a reliable, professional system.
3. Threads and Timers over State Machines
Arduino is mostly loop-driven. That works fine—until it doesn’t. As things grow, your loop() becomes a spaghetti mess of state machines and timing hacks.
We switched to proper threads and timers (hello, esp_timer and FreeRTOS tasks), and the code became instantly more modular and readable. You do have to think about concurrency now—but that’s a small price for clean architecture.
4. Build Times That Don’t Kill the Flow
Using Cursor (and previously Trae) with ESP-IDF and Visual Studio Code, the build pipeline is finally fast. Full build and flash in ~20 seconds. No more 5-minute compile cycles just to test a 3-line change.

Building no longer is a coffee break; to change a single file, most of the time is spent flashing the new image.
Provisioning: Still a Pain Point
Provisioning—getting the device on WiFi—is still an industry-wide headache.
Right now, you have two real choices:
Device-based setup: A captive portal hosted by the device itself.
App-based setup: A phone app that uses Bluetooth or WiFi to find and configure the device.
We chose the captive portal route for now. It’s decent, but not perfect. I hate the idea of every product needing its own app, but if users struggle with the captive portal, we may have to bite the bullet.

The new captive portal – simple UI and Wi-Fi network scanning.
The Result
We ended up with:
A clean, modern firmware stack that works flawlessly on the latest ESP core.
A polished UI with more settings and customization options (like scroll behavior, timezone autodetection).
A brand-new backend, built in just a couple of days, thanks to AI-assisted coding.
Yes, vibecoding is the word—when tools work with you, software development feels fun again.
Pitfalls and Gotchas
Let’s be real—AI isn’t perfect.
It helps a lot, if you know what you’re doing.
It sometimes writes bad code. I lost an hour debugging a bug where it hardcoded the wrong string length.
You still need to review everything.
But I’ll say this: AI has gone from “neat toy” to “critical tool” in less than a year.
I guess vibecoding itself (writing code with an AI without ever looking at the results) is a dangerous path – at least for now. But having the AI do the grunt work (including unit tests and everything) and then you checking the results – that is just awesome.
Outlook
This is a brave new world. The tooling has matured dramatically. I truly believe we’re entering a phase where better tools lead to better software, because developers can try ideas faster, test more thoroughly, and iterate at the speed of thought.
And maybe in a few years, we’ll stop writing apps altogether—and just describe the outcome we want.
