I Built a Sailing Start Timer for My Watch. Here's What It Taught Me About AI-Assisted Development
- Artificial Intelligence
- Claude Code
- Innovation
Five minutes, one line, no do-overs
A sailboat race is often won or lost in the last 60 seconds before the gun. You want to hit the starting line at full speed, exactly as the clock reaches zero. Too early and you're over the line and have to restart. Too late and the fleet sails away from you.
When I'm racing, the one tool I rely on most is my watch. Garmin's Connect IQ store offers a wide variety of sailing apps, and I tried plenty of them. None worked quite the way I wanted. Two things kept coming up short:
Sync-down. I wanted one press to snap a running countdown to the nearest minute when the committee's signal goes, without stopping the clock or digging through menus.
Activity logging. As an avid Strava user, I wanted the race itself recorded cleanly, ideally starting the moment I cross the start line, not a long log full of pre-start circling.
So over a few days in May 2026 I built my own Garmin app, SailStart Pro, with Claude Code as my development partner.
This post covers what the app does and, more importantly, what the project showed me about AI as a development partner. Bring critical thinking and problem solving, pair them with today's AI tools, and one person can build things that used to take a team. That matters well beyond sailing, because it's the same approach I bring to client analytics work at Loma Analytics.
What SailStart Pro does
SailStart Pro runs on my Garmin Fenix 5X, a 240×240-pixel round display with five physical buttons and no touchscreen. Every feature had to work with wet hands, in glare, while I'm also steering a boat.
The app supports five start formats: the standard 5-minute ISAF sequence, a 3-2-1 start, a match-race sequence (5, 4 and 1 minute signals), a countdown to a fixed gun time, and a custom countdown of 1 to 60 minutes.
The controls are the features racers actually use on the water:
Sync. One press snaps a running countdown to the nearest whole minute, so you can line up with the race committee's signal without stopping the clock.
Minus one minute. Covers a missed signal instantly.
Signal timing. Optional beeps every 10 seconds in the last minute and every second in the last 10.
Race screen. A 2×2 grid you configure from 12 metrics, including speed in knots, course over ground, heart rate, tack count, leg distance and distance to line.
Activity recording. The session saves to Garmin Connect as a normal activity and flows on to Strava. You choose the whole session, the race only (so the pre-start circling stays out of your feed), or nothing.
Sync and race-only logging were the two features I couldn't find done my way, and they're the reason the app exists.
A bonus feature: Line Pings
Once the basics worked, I added one extra. Before the start, I sail past the committee boat and the pin and press START at each to record its GPS position. The watch then shows a live distance to line on the countdown screen and in the race grid.
The math is light: flatten the line onto a local x/y grid, take the perpendicular distance, and correct for heading. The edge cases took more thought. Below 0.3 knots, or within 10° of parallel to the line, the app falls back to the plain perpendicular distance and puts a tilde in front (~42m), so I know not to fully trust it.
How it got built: spec first, code second
I'd never written Monkey C, the language Garmin uses for watch apps. The finished app is roughly 3,400 lines across 33 source files, built over three days. That pace only worked because I didn't start by asking an AI to "build me a sailing timer."
The workflow had three stages, and each produced a written document before any code existed:
Design spec. For each feature, I worked with Claude to write a spec that pinned down every decision: what gets stored, the sign convention, the display rules, and which screens change. It also set principles, such as "purely additive," meaning that if you never use a new feature, the app behaves exactly as it did before.
Implementation plan. The spec became a task-by-task plan listing every file, every method signature and the build check after each step.
Agent execution. Claude Code worked through the plan one task at a time, compiling after each change and fixing errors before moving on.
The same loop produced the base app on May 26, Line Pings on May 27, and a plan for supporting larger watch screens on May 28.
This mirrors how I run client engagements. On a Power BI project, discovery and a scoped statement of work come before anyone opens Power BI Desktop. The AI didn't change that discipline. It made the discipline pay off faster.
AI as a development partner
Claude was a real partner here, not an autocomplete. It wrote most of the code, read its own compiler errors and fixed them, and turned plain-English decisions into Monkey C. My side of the partnership was the critical thinking and problem solving, and the most useful lessons came from the gap between "it compiles" and "it works on my wrist":
The platform is older than the AI's assumptions. My Fenix 5X runs Connect IQ 3.1, and code that's normal on newer watches simply doesn't exist there. There's no way to ask the system for the current screen, no remainder operator for decimal numbers, and no arrow symbols in the built-in fonts. Each one showed up as a compiler error that had to be tracked down and written into the project notes so it wouldn't happen again.
Some failures only appear at runtime. I wanted distance to line saved into the activity file, so I could analyze my starts afterward. The API for custom data fields compiled fine but isn't available on my watch, and the resulting crash got past the app's error handling. Separately, a decimal-precision mismatch in the math crashed the app inside the GPS update loop. Neither problem appears until the app runs, and both are now documented rules.
Judgment calls stayed mine. The AI could implement any sign convention for "which side of the line," but deciding to trust the approach direction over a wind-based guess came from knowing how people actually sail into a start. The same goes for when to show a tilde instead of a number you can't trust.
I keep a running file of these platform rules that the AI reads at the start of every session. Each mistake gets fixed once and stays fixed. That's the most transferable habit from the whole project.
What's next, and why this matters for analytics work
The next step is the layout work already planned: replacing the fixed 240-pixel coordinates so the app renders correctly on newer 260- and 280-pixel Fenix screens. After that, the bigger goal is getting this data off the watch and into a sailing analytics platform, where every start can be reviewed by its distance to line, speed at the gun and choice of line end.
The watch app is a hobby, but the lesson applies directly to client work. AI is a genuine development partner: it took a language I'd never used and helped me ship a working app in three days. It worked because I brought the critical thinking, the spec, the edge cases, the runtime testing and the judgment about how sailors actually race. Pair that kind of problem solving with today's AI tools and there's very little you can't build.
A Power BI model works the same way. The tools can write the DAX quickly, but deciding what the numbers should mean, and knowing when they're wrong, is still the job.
If your team is weighing how to bring AI into its reporting and analytics work without giving up that rigor, get in touch.