Coach
Taking an AI exercise coach from concept to a stateful MVP
Led the product definition, MVP scoping, architecture trade-offs, and iterative development of Coach—a stateful, WhatsApp-first personal AI exercise coach built around consistency over intensity.
- Project
- Self-directed product initiative
- Product category
- AI-powered fitness
- Primary interface
- WhatsApp-first
Case Study Contents (16)
Project overview
Coach is a personal AI exercise coach designed to help people exercise consistently through practical, context-aware workout guidance. The idea began with a familiar problem: people often struggle to maintain an exercise routine, while generic workout recommendations do not necessarily account for individual circumstances.
A useful coach needs to consider more than a fitness goal—accounting for a person's experience, available exercises, time constraints, previous sessions, feedback and current circumstances, and recognising when a lighter session or rest is more appropriate. I defined Coach around a simple principle: consistency over intensity.
The product evolved beyond one-off AI-generated workout plans into a stateful coaching experience designed to retain relevant user information, generate structured workouts, collect feedback and use previous activity to inform future recommendations. I led product definition, MVP decisions, technical direction and iterative development, alongside working directly on implementation, testing and integration.
The product challenge
A generic AI assistant can suggest exercises, but ongoing coaching requires more. Without persistent context, a person has to repeatedly explain their goals, experience and prior activity; without structured exercise data, a model may recommend unavailable movements or inconsistent workout details; and without feedback, the product cannot learn what happened after a recommendation was made.
The central challenge was moving from an AI that generates workout suggestions to an application with the foundations of an ongoing coaching relationship across seven connected requirements:
- —Maintaining relevant user context between interactions.
- —Generating practical workouts from a controlled exercise catalogue.
- —Producing structured information that the application could validate and store.
- —Distinguishing planned workouts from completed sessions.
- —Using feedback and workout history to inform subsequent recommendations.
- —Establishing safety expectations for an exercise-related AI product.
- —Making the experience accessible through a familiar communication channel.
My role
I led the product direction and development of Coach as a self-directed product initiative, combining product decision-making with direct technical involvement and verification:
- —Defining the product vision and intended coaching experience.
- —Translating the concept into functional requirements.
- —Establishing the MVP scope and delivery sequence.
- —Making architecture and technology trade-off decisions.
- —Directing implementation of the AI interaction and exercise capabilities.
- —Defining persistent user profiles, workout history and feedback requirements.
- —Establishing structured workout validation.
- —Identifying safety risks and translating them into product rules and tests.
- —Managing development constraints and technical troubleshooting.
- —Planning and testing the WhatsApp integration.
From a generic chatbot to a stateful coaching product
One of the most important product decisions was making Coach stateful. A chatbot generating a workout from a single prompt does not understand what happened during previous sessions or how a user's circumstances have changed. Supporting continuity required moving beyond temporary conversational context to persistent application data:
- —User profiles.
- —Workout sessions.
- —Individual workout exercise records.
- —Structured workout feedback.
- —Retrieval of relevant profile and workout history.
- —Context-aware workout generation.
This reframed the product around an ongoing coaching loop and established a key business rule: a workout being generated or planned must never be interpreted as proof that the user completed it.
Implementation status: Persistent profiles, workout records, context retrieval and feedback capabilities were implemented and tested.
Making deliberate AI architecture decisions
I evaluated the level of architecture actually needed for the MVP, selecting Google Gemini for AI reasoning and tool orchestration, Python functions and services for application operations, Pydantic for structured workout data, PostgreSQL for persistent information, and explicit validation logic to check generated structures.
I deliberately avoided introducing frameworks and infrastructure such as LangChain, LangGraph, CrewAI, RAG, vector databases and multi-agent orchestration. Because Coach had a focused product problem, adding orchestration layers before establishing the core coaching loop would have introduced unnecessary complexity without demonstrated user value.
Implementation status: The selected application architecture was implemented.
Establishing a controlled exercise library
Allowing a language model to invent arbitrary exercises makes recommendations hard to control and validate. I prioritised a structured exercise catalogue containing 26 structured exercises with identifiers, categories, muscle groups, relationships and exercise properties.
The AI agent uses application tools to retrieve exercise information and filter the catalogue, creating a clear boundary between model reasoning and authoritative exercise records and establishing a consistent foundation for workout generation.
Implementation status: Implemented and tested.
Turning AI responses into validated workouts
A workout that sounds plausible in chat is not necessarily usable by an application. To ensure workout plans could be processed, validated and persisted reliably, I specified structured workout generation using Pydantic schemas enforcing:
- —References to valid exercises.
- —Required exercise measurements.
- —Correct measurement types.
- —Valid set counts.
- —Rejection of invalid workout structures.
This separated two responsibilities: the AI proposes a workout, and the application checks whether the proposal satisfies its data requirements—ensuring the system never accepts invalid data merely because a model response sounds confident.
Implementation status: Structured generation and validation were implemented and tested.
Designing the coaching feedback loop
An adaptive coaching experience needs visibility into what happened after a recommendation was made. I designed Coach around a continuous loop:
The application stores workout sessions, individual exercises, session status and structured feedback while strictly distinguishing planned sessions from completed ones, recognising that workout history alone cannot assume recovery or readiness.
Implementation status: The core persistence and feedback capabilities were implemented and tested. More advanced recovery and progression logic remains deferred.
Defining the MVP and managing scope
While the longer-term vision included advanced recovery, progression, safety and evaluation capabilities, trying to build everything upfront would have bloated the MVP. I sequenced implementation around ten foundational stages:
- 01Establish the Python application foundation.
- 02Implement Gemini interaction and tool calling.
- 03Build the exercise library.
- 04Implement structured workout generation.
- 05Add workout validation.
- 06Establish PostgreSQL persistence.
- 07Implement stateful coaching and feedback.
- 08Complete an essential safety review.
- 09Extend the experience through WhatsApp.
- 10Deploy and perform end-to-end testing.
Advanced recovery and progression were deliberately deferred until the foundational coaching loop could be tested and informed by real usage.
Implementation status: The foundational capabilities through feedback and essential safety review were completed. WhatsApp integration and deployment remain in progress.
Making WhatsApp the primary interface
I chose a WhatsApp-first experience rather than building a full web application before validating the core coaching loop, keeping the coaching logic decoupled inside the backend rather than embedded inside the messaging layer.
Implementation began with Meta's WhatsApp Cloud API, a Python messaging client, outbound message testing and a FastAPI webhook verification endpoint. After investigating an initial HTTP 400 response by comparing dashboard test payloads, inspecting the messaging window and initiating a conversation from the registered recipient, outbound delivery succeeded and local webhook verification returned HTTP 200 with the expected challenge response.
Managing development constraints
When GitHub Codespaces connectivity became unreliable, I transitioned development to a dedicated local Ubuntu environment to eliminate repeated interruptions while preserving project isolation:
- —Python 3.12 and Git.
- —PostgreSQL 16 on a dedicated cluster (port 5433) with a separate coach database and coach_user.
- —An isolated .coach-venv Python environment.
- —Local environment configuration, Zed editor setup and a reusable jhay shell shortcut.
Keeping Coach's database isolated from the PostgreSQL instance used by another project removed a practical blocker without disrupting unrelated work.
Implementation status: The local development environment and database were configured and verified.
Treating exercise safety as a product requirement
In fitness coaching, inappropriate recommendations carry real risk. I strengthened broad safety expectations into explicit product rules—prioritising consistency over intensity, avoiding workout debt or punishment for missed sessions, avoiding medical diagnosis or invented recovery data, responding cautiously to symptoms, halting aggravating movements, respecting disclosed injuries, avoiding extreme volume or unsafe progression, asking clarifying readiness questions and recommending professional assessment where appropriate.
Three manual conversational scenarios were tested against these rules:
| Scenario | Observed result |
|---|---|
| Chest pain and dizziness | Coach advised stopping exercise and seeking urgent medical attention |
| Knee injury | Coach rejected the requested squats and lunges, suggested rest and alternatives, and prompted further consideration of the condition |
| Missed workouts | Coach discouraged intense compensatory workouts and reinforced a manageable return |
All three manual scenarios passed in observed testing. However, these represent three manual conversational checks rather than a comprehensive safety validation programme, and the automated test suite does not establish medical safety.
Testing the implemented product
I combined automated tests and manual checks to verify implemented behaviour. The most recent recorded full test run reported 24 automated tests passed, with 31 subtests passed in 16.03 seconds, covering coach context, the exercise library, exercise tools, persistence, session persistence, stateful behaviour, workout validation and workout feedback.
Manual verification also covered database connectivity and migrations, CLI profile creation and selection, workout generation, WhatsApp message submission and receipt, local webhook verification, the three safety scenarios, and persistence across application restart (creating a profile, saving a workout, restarting the CLI and confirming retained history).
These results demonstrate functional verification of the implemented capabilities; they do not establish user retention, workout adherence, health outcomes, commercial viability or production reliability.
Current product status
Implemented and tested
- —Gemini interaction and tool calling.
- —Structured exercise catalogue containing 26 exercises.
- —Workout generation using structured schemas and validation.
- —PostgreSQL persistence, user profiles and workout history.
- —Stateful context retrieval and structured workout feedback.
- —Essential safety instruction improvements.
- —Local development environment and automated test suite (24 passing tests, 31 passing subtests).
In progress
- —WhatsApp integration.
- —Public webhook registration and incoming message processing.
- —Connecting WhatsApp interactions to the Coach agent.
- —Deployment and end-to-end testing.
Deferred
- —Advanced recovery and progression.
- —More comprehensive safety evaluation.
- —Formal product evaluation based on real usage.
Coach is currently a functioning local MVP with an unfinished WhatsApp integration and has not been established as a launched product.
What this experience demonstrates
Coach provided hands-on zero-to-one experience across eleven Product Management areas:
- —Zero-to-one product definition: Turning an initial concept into a defined AI coaching product.
- —Product strategy: Establishing a stateful coaching experience rather than a generic workout chatbot.
- —Requirements management: Translating coaching needs into profile, history, feedback and validation requirements.
- —MVP prioritisation: Sequencing foundational capabilities and deliberately deferring advanced functionality.
- —Technical product management: Making architecture and infrastructure decisions with an understanding of implementation consequences.
- —AI product management: Defining agent behaviour, tool calling, structured outputs and controlled information sources.
- —Data and workflow design: Connecting user profiles, sessions, exercise records and feedback into a continuous product workflow.
- —Quality assurance: Using automated tests and manual scenarios to verify application behaviour.
- —Risk management: Turning exercise safety expectations into product rules and test cases.
- —Integration management: Working through the requirements and testing of Meta's WhatsApp Cloud API.
- —Delivery management: Changing the development environment to remove a practical blocker.
Reflection
Coach reinforced that building an AI product involves considerably more than connecting a language model to an application. Its usefulness depends on the information it can access, the boundaries placed around its behaviour, output reliability and how it learns from interactions over time—including invisible decisions around state, planned vs. completed sessions, controlled exercise references, validation, MVP sequencing and safety rules.
The next important stage is completing the WhatsApp experience, deploying the product and observing real usage—moving beyond functional verification to examine onboarding, repeat engagement, workout completion, recommendation usefulness and adaptation to feedback.
I would not yet claim that Coach has improved exercise adherence, achieved product-market fit or produced health outcomes; those remain questions for real-world validation. For now, Coach represents a substantial zero-to-one product development experience: defining a product, making deliberate trade-offs, directing implementation, testing the result and identifying what must be proven next.