From zero Garmin experience to shipping our MVP in a month

I shipped the AllTrails app for Garmin watches to 120 devices this October, on a platform I’d never touched before. Agents wrote the code. I reviewed it lightly and focused on verifying outputs to ship with quality.
This is for engineers using coding agents on a platform they don’t know yet, or for anyone interested in a story of doing that at scale.
What worked for me was setting the project up for agents from day one: a knowledge base in the repo and a harness that let them check their own work on every device.
I’d never touched a Garmin, but I was intrigued
A lot of our users at AllTrails navigate with a Garmin, and getting a route onto the watch took a lot of steps. An app on the watch itself would be a big win. Problem was, nobody at the company knew how to build one.
Garmin apps run on Connect IQ and are written in Monkey C, a purpose-built language that not many know. I’d never touched Garmin, Connect IQ, or Monkey C. At the time, I didn’t even own a Garmin. But as an avid backpacker, I was intrigued by the phenomenal battery life I could get over my existing Apple Watch Ultra 2, and after a summer of many backpacks I felt motivated to make something happen here.
Realistically, before agents, it would have taken someone months to ramp up. We had wanted to build this for years and just never had the bandwidth.
So the weekend after a company off-site, I started long-running agent sessions on one question: could we get anything running at all? Soon, I had a basic prototype of what I envisioned in the simulator, using completely fake data.
This got me really excited. I went out and bought a fēnix 8 as a development watch. I then worked with agents to stream dummy data to it from a dev server on my laptop. That brought it to life, and I pitched it hard across the company. I got leadership buy-in, and it was go time!
On balance: I wasn’t starting from zero here. Feal, the side-project app I built, had already taught me agent-first habits while I ported the iOS app to Android: snapshot testing, a focus on test quality, and verifying outputs instead of reading every line of code.
In the AI era, building high levels of trust in hands-off agent output where it’s safe to fail is worth its weight in gold. That certainly helped me feel confident enough to go for this.
Write the knowledge down before the code
I knew from the start this had to be an AI-native project, built for agents to work in. So before any serious code, I had agents document everything they could find: best practices for Connect IQ and Monkey C, the platform’s capabilities, and the devices themselves.
It all went into Markdown files in the repo. The goal was a knowledge base the agents maintain and keep coming back to, so a new session doesn’t redo the research.
That paid off on the technical parts. Which built-in menus are there? What font sizes does each watch have? How much memory does an app get? What’s the purpose of the app? Anything that needed research became tidily indexed and tucked away for agents.
With a growing heap of knowledge built into the project, I could brainstorm with an agent and figure out the details with it, instead of me ramping up for ages first.
The other half of this was the checks. I had the agents fact-check what they wrote against Garmin’s docs, the SDK samples, and the Garmin forums, or even the simulator itself when nothing else had the answer. They also wrote down what they learned, for both themselves and me.
Prototype fast, then rebuild it for agents
The prototype was deliberately simple. A server on my laptop had a few dummy endpoints, and I flattened every kind of AllTrails data into a single route type.
A route answered four questions. How long is this thing? What’s the elevation change? What’s it called? Can I navigate it? For an MVP, that’s really all that mattered, and the platform forced that simplicity anyway.
Once it got real interest and roadmap time, I rewrote it from scratch. I treated each screen like a finite state machine with explicit states and actions. Since I wasn’t writing the code by hand, I knew that would be key to actually maintaining it.
That architecture is what made the harness possible. A custom hook reads the running app’s state and can force the app into any state, so an agent can use CLI tools to make a simulator scrub to any screen at any moment.
Every screen exposes actions that mirror what a user can do, or what the environment can do: a failed network request with a specific error code, or a stubbed response. They run through the same hooks as the real events.
On top of that came behavior-driven unit tests aiming for complete coverage, then flow tests through the harness on happy and sad paths. By launch, there were nearly a hundred flows.
Review the shape, not the lines
I understood the high level and lightly reviewed the code, but after reviewing the early work I stopped seriously scrutinizing the logic line by line. It just wasn’t worth the time, nor was it feasible given the roadmap time I had.
Between prototyping on my own time, chipping away between projects, and the dedicated roadmap time, I put about 4 weeks of “human time” into the build. This was against roughly 5 weeks of “agent time.” As we know, agents can crank out greenfield code like no other. I couldn’t have possibly read all of that code in detail.
Since I really wanted to make this happen but had limited roadmap time, I chose to adopt a growth mindset and view this as a crucible. Wild timelines can bring wild results, as long as we take care of ourselves along the way, too. The only possible way to pull off this Garmin dream of mine would be to rethink how I build software. Obviously not by hand, and obviously not “completely vibe-coded” either.
The sweet spot? Focus on the outputs, but in a super nerdy, engineering kind of way.
So I first pointed my energy at building the tooling I needed, starting with that harness I mentioned earlier.
The harness was a series of command-line tools that could request and read back everything, from the state machine to what’s on screen. From that, agents generated state diagrams that let me check the system and its data flows at a higher level.
Then came snapshot tests with visual diffs that mirror the flow tests. They let the agents debug and see what they’d built, and they let me review the app one flow at a time. Visual diffing ensured I only reviewed what changed, and unexpected diffs were either proactively fixed by the agent or flagged to me during review.
By the end, I was mostly reviewing snapshot flows and talking through the bigger questions. What do we need from the server? How should we architect it? Working on it by myself, I was serving as my own product manager and technical project manager.
Wearing this many hats with nearly complete agency over the app was a blast, but without agents and the strong dev tooling behind it, there’s no way I’d have shipped this without staying high-level on the coding itself.
Let the harness see everything
I did most of my development on that fēnix 8. The harness checked the other 100-plus devices. They come down to about 20 meaningfully distinct screen shapes: circles, small and big rectangles, really short screens where an app can use only a small area at the top left, etc.
One version of the snapshot tool shows every state on every device, narrowed down by device family. At first, reviewing it all took real time. After that, as long as nothing major changed and nothing got flagged, I was good to go.
Dozens of times, it caught a layout that just didn’t work on some device.
When German broke the pairing flow
The biggest design changes came from long languages like German, one of the dozen or so languages the app ships in. On the small round watches, the most popular ones like the fēnix, Forerunner, and Venu, the pairing instructions would have scrolled for pages upon pages.
There was no way to keep the existing design simple and consistent while still fitting a typical watch screen. So I redesigned pairing as a step-by-step flow, one short step per screen, which some technical limits needed anyway.
The Instinct was the hardest. A round window sits in its top-right corner, cutting off crucial space on an already limited screen. This forced a design where every step got three lengths of text: the ideal description, a medium one, and the shortest (one word).
Each device then shows the longest one that fits.
Exposing changing languages in the harness snapshots and flow tests made it possible to iterate and verify that all of this looked reasonable across many devices, in like a day, instead of a week or two.
Catching sneaky issues
On top of my manual QA, we also did a bug bash with all the Garmin-owning AllTrails employees we could find. Surprisingly few bugs came up, but we did flag a couple launch blockers where we didn’t like the functionality.
The fixes for two of our launch-blocker issues compiled on every device and passed every unit test, but introduced sneaky, serious issues.
The first one was a runtime crash caused by a menu theme that older devices don’t have. It happened on ~50 devices and would have crashed the app on each home screen render.
The second was a number font with no letters, drawing the pairing code as empty boxes on ~70 devices. This would’ve been a total showstopper.
Neither of these happened on the typical devices I’d test, of course. Only the snapshot and flow tests caught them, the harness tooling saving the day yet again. Otherwise, these kinds of pre-release fixes on tight timelines could easily have become something much worse.
Help agents help themselves
The agents kept stumbling on the simulator itself. Out of the box, Garmin’s tooling runs one simulator at a time, and there wasn’t much info out there on running several in parallel.
I often run several large streams of agent work at once with Robowright (an open-source orchestration system I built for Claude Code), and every workstream needed a simulator. That made the simulators and their verification loops the new bottleneck.
At first, my dev tooling was a mess. Simulators crashed repeatedly when switching devices, the tooling was flaky, and the agents couldn’t tell whether it was OS-level edge cases or tooling limitations. Some early workarounds were hacky: wait out an observed stall between suites, sometimes for 10-15 minutes at a time.
It worked, but it wasn’t always trustworthy, and it was way too slow.
So I intentionally spent a lot of time on it, even allocating 1-2 of my precious simulator slots. Over a week or two, while other Garmin work streams were in flight, I kept pitching ideas to the agent until it found the crux of the issue. I don’t remember the exact details anymore, but I think it had been mistaking crashes in our own tooling for OS or simulator limits. Once we fixed that, the timeouts and stalls thankfully disappeared.
I eventually got five simulator slots reliably running at once, with a checkout system so each agent could claim one. A full snapshot run went from over an hour to under thirty minutes, and 2-3 workstreams could happen at once.
The first time I saw them all on my screen, five simulators rapidly cycling through the app states and devices, I thought: wow, what even is my life anymore? My screen looked insane, but it was pretty cool.
Where being a rookie cost me
Time was the first thing, of course. Even with agents and doing “all the right things,” I learned the hard way every time a layout or flow I’d planned didn’t work on some class of devices.
The harness itself cost a class of devices. It adds about 12 KB, which pushed the 96 KB devices over the edge: the tooling couldn’t test them, so they’re deferred for now. I bet an experienced Garmin dev would have planned for that, with tricks for app size or per-device builds.
An on-route map became a spike after launch. With the expertise, I think at least route map visualizations would have made the MVP.
Sadly, I don’t know what I don’t know, and that’s probably the scariest thing about doing something new like this. I’m confident there are no safety issues, since the navigation itself is Garmin’s own. But where there is software, there are software bugs, and I’m sure some of the issues we’ll eventually discover are because I’m a total rookie with Garmin.
The repeatable takeaways
Next time I’m on a platform or feature I’ve never touched, I’ll build the knowledge base before the code. I’ll have agents fan out far and wide, write it down, and fact-check it. Then I’ll get a rough end-to-end prototype working (a “tracer bullet” of functionality), and re-architect once I know enough. If the code’s in a place I can do it, I’ll focus on building tooling to enable quicker feedback loops for agents.
A lot of this was enabled by agent skills I’ve built or picked up along the way, too. Some key ones were behavior-driven tests, mutation testing gating, and adversarial review. You can find these skills, and many more, in Robowright.
Drafted from my dictation with an agent, then edited by me.