Splash

Side build · Rowing app

Splash

A rowing app built entirely from scratch in ~25 hours using AI assistance. Test-driving complete product execution from ideation to working cross-platform prototype.

Product & full-stack 2026

Overview

Coaching logic turned into code

Splash interface

Product

Training loop

Set a goal, follow a structured plan, and adapt sessions based on real fatigue. Workouts are designed from elite coaching programs defined with Maxime Ducret.

Team & context

AI-assisted sprint

A side-project built to test AI development tools (Cursor). Scoped to explore rapid product and technical execution from zero to prototype.

My Role

Full ownership

Product strategy, UI/UX design, domain logic extraction with a coach, and full-stack implementation using Cursor, Supabase, and Vercel.

The opportunity

Filling the void in rowing software

The friction

No guidance

Runners and cyclists have dozens of training apps. Rowers don't. They repeat the same generic sessions without knowing if they're on track for their goals.

The challenge

Software that acts like a coach

Deliver quality coaching guidance without pretending AI can replace a human. Turn real-world coaching principles into a structured but flexible digital plan.

How it works

A training engine guided by fatigue

Set a goal, follow a structured plan, and let your actual state of recovery dictate the next optimal workout.

Intention

Set your goal

Choose a distance (500m to 6k), enter your current time, and a target date. Splash calculates a realistic improvement target based on training science.

Programming

Get your plan

The app generates workouts using Maxime's coaching programs. Each session is uniquely mathematically adapted to your current level and goal.

Execution

Train and adapt

Log sessions (rowing or other sports). The app tracks fatigue and adjusts the plan week-to-week to fit how you're actually feeling, like a real coach.

Splash main screen
Splash second screen

Execution

Iterating on code, not wireframes

Product strategy

Cut ruthlessly

Stripped the scope down to one core flow: set a goal, get a plan, adapt to fatigue. Just the athlete's training loop, enabling an end-to-end build in under 30 hours.

Domain modelling

Encode expert knowledge

Worked with a champion turned full-time coach to translate his training principles (intensity zones, progression, race prep) into usable algorithms.

Training experience

Build around fatigue

Rather than tracking volume blindly, the app monitors fatigue across all activities to recommend what to do next. Plans adapt to life, not just theory.

Execution layer

Ship with AI assistance

Used Cursor with Supabase/Vercel. Prototypes in code instead of Figma. Generated, refined, and enforced architectural standards through strict AI prompting.

Result

From idea to working prototype in 25 hours

A testable product

Not a mockup

Rowers can create goals, receive workouts, log sessions, and watch fatigue evolve. It's an early-stage but fundamentally complete beta.

Proof of concept for AI dev

New workflows

Demonstrated that AI excels at rapid prototyping if someone owns architecture. Product thinking is the bottleneck now, not boilerplate.

Unplanned traction · one month after release

300+ users

Zero marketing effort, just word of mouth among rowers after a few social posts.

1,000+ sessions

Training sessions logged by real rowers, proving the core loop works.

Positive retention

Users keep coming back without prompts, the product creates a weekly habit around structured training.

Retrospective

What I learned

Speed favours feedback over speculation

Getting to a testable app in twenty hours changes the equation. You can afford to learn from users much earlier rather than over-engineering on paper or trying to future-proof everything before launch.

Scope discipline matters more, not less

Faster building means it's easier to overbuild. Saying no to everything beyond the core training loop was essential to keeping this shippable.

AI is a fast junior, not a senior

Cursor drafts code incredibly quickly, but it doesn't replace architecture. It builds complex tangles if left unattended. Visual hierarchy, interaction details, and UI polish still require strong human product judgment.