How I AIHow I built an Apple Watch workout app using Cursor and Xcode (with zero mobile-app experience)
CHAPTERS
- 0:00 – 1:11
Why a voice-first workout tracker: from gym inconsistency to structured analytics
Claire and Terry set up the core problem: staying consistent at the gym is hard, and traditional fitness apps feel like too much setup and manual logging. Terry explains the spark—using the ChatGPT mobile app as speech-to-text—and the idea of turning voice into structured workout data with analytics.
- •Pain point: forgetting routines after gaps in training
- •Existing apps require heavy setup, accounts, and manual input
- •Insight: speech-to-text can capture workouts hands-free
- •Goal: turn voice into structured records + analytics
- 1:11 – 2:38
Sponsor: Paragon (product integrations)
Claire shares a sponsor message about Paragon, a tool for shipping product integrations faster than building in-house or relying on limited unified APIs. The pitch emphasizes high-volume ingestion, real-time actions, and reducing integration build time from months to days.
- •Integrations as a critical product/SaaS requirement
- •Limitations of embedded iPaaS and unified APIs
- •Paragon’s focus on fast, reliable integrations
- •Call to action and discount link
- 2:38 – 4:23
What Terry built: Cooper’s Corner across iPhone + Apple Watch
Terry introduces Cooper’s Corner, a mobile fitness tracker built with AI, and describes the desired experience: minimal friction, no “homework,” and fast logging. Claire frames the episode as a mobile/watch-focused AI-building walkthrough using Cursor, Xcode, and even index cards.
- •App concept: voice-powered workout tracking
- •Cross-device experience (iPhone + Apple Watch)
- •Positioning: reduce friction vs traditional trackers
- •Tools: Cursor + Xcode; prototyping with index cards
- 4:23 – 6:42
Live demo: voice logging, transcription, and sync between Watch and phone
Terry demos Sign in with Apple and the core flow: speak an exercise, weight, and reps, then see it transcribed and saved as a structured log. The same workflow works on both Apple Watch and iPhone, with data syncing between devices for in-gym convenience.
- •Authentication choice: Sign in with Apple for low-friction onboarding
- •Voice capture on Watch and phone
- •Automatic transcript + structured fields (exercise/weight/reps/time)
- •Cross-device sync so either device can log workouts
- 6:42 – 7:23
Analytics and history views: consistency tracking and progression over time
Terry shows the app’s history and analytics features that help answer “have I been consistent?” and “am I progressing?” Users can view 7/30/90-day activity, top exercises, and per-exercise history including a visual progression view.
- •Consistency metrics (e.g., gym days in last 30 days)
- •Top exercises surfaced from logs
- •Per-exercise drill-down with historical records
- •Progress visualization (e.g., scatter plot of weight over time)
- 7:23 – 9:22
Dual-wielding Cursor and Xcode: a practical mobile AI dev setup
Terry explains why iOS development typically requires Xcode, and how he pairs it with Cursor by pointing both tools at the same project folder. Cursor handles most code generation/edits, while Xcode remains essential for builds, simulator/device runs, and debugging compile-time issues.
- •Xcode as required Apple IDE for building iOS/watchOS apps
- •Side-by-side workflow: Cursor codes, Xcode builds/debugs
- •Mobile debugging differs from web (no simple localhost + console loop)
- •Watch builds/testing add extra complexity
- 9:22 – 11:28
From zero to v1: Voice Memos → Python → GPT → spreadsheet, then a real backend
Terry walks through his earliest prototype: recording workouts via Apple Voice Memo on the Watch, moving files to a computer, and using a Python script + GPT-4 to generate a spreadsheet. The limitations of unstructured spreadsheet outputs pushed him toward a database and backend API for consistent, queryable data.
- •MVP: record voice notes, then transcribe and summarize via GPT
- •Python automation to output results into Excel
- •Problem: inconsistent/unstructured data limits analytics
- •Next step: database + backend API for structured data (foreign keys, consistency)
- 11:28 – 13:14
Three-step AI workflow in Cursor: PRD create → PRD review → PRD execute
Terry outlines a repeatable system for getting reliable results from AI coding: generate a PRD, have a model critique it for gaps, then execute via a phased checklist. He uses Gherkin-style scenarios, explicit file lists, and pause points with Git commits to reduce risk and improve one-shot success rates.
- •PRD creation rule to turn an issue into an implementation plan
- •PRD review rule: rate “could another model execute this with zero context?”
- •Execution rule: phased checklist with stop points
- •Use of Gherkin user stories and explicit file/endpoint references
- •Safety: Git commits before/after phases to enable rollback
- 13:14 – 19:47
Sponsor: Miro (Innovation Workspace)
Claire shares a sponsor message about Miro’s Innovation Workspace and its AI copilot to turn brainstorm artifacts into diagrams, product briefs, and prototypes. The segment emphasizes faster iteration, collaboration, and reducing cycle time.
- •AI copilot inside a collaborative canvas
- •Turn stickies/screenshots into structured outputs
- •Supports roadmaps, briefs, diagrams, and prototyping
- •Call to action to visit Miro
- 19:47 – 23:26
Token conservation and “vibe refactoring”: keeping AI output manageable
Claire and Terry dig into why limiting tokens and context can improve outcomes: large files and verbose generations slow the workflow and increase errors. Terry describes “vibe refactoring” as a planned phase where AI helps reorganize and clean code after rapid feature-building to reduce tech debt and improve reliability.
- •Motivation: sanity/performance, not just cost
- •Large files increase context churn and model mistakes
- •AI can generate working code fast but may introduce tech debt
- •Dedicated refactor workflow/rule with QA checkpoints
- 23:26 – 25:29
Optimizing for your AI teammate: smaller files, line counts, and easier navigation
Terry explains a concrete codebase design principle: keep files small enough that the model can reason over them efficiently. He uses quick line-count scans to identify “god files” and breaks them down, aiming for ~200–400 lines so the AI spends fewer tokens reading irrelevant context and makes fewer mistakes.
- •Design principle: file size optimized for LLM context handling
- •Technique: line-count to find refactor targets
- •Example: ~900-line recorder file flagged for refactor
- •Phased refactor plan with compile/error checks and safety checklist
- 25:29 – 29:01
“Rubber duck” rule: using AI to explain, quiz, and accelerate learning
To avoid shipping code he doesn’t understand, Terry uses a “rubber duck” workflow where the model explains files line-by-line and even quizzes him. This turns AI-assisted building into a learning loop, improving debugging instincts and helping him spot model mistakes faster over time.
- •Rubber-ducking: explain code as a learning/debugging tool
- •Model-generated walkthroughs and “pop quiz” prompts
- •Addresses fear: vibe coders shipping code they don’t understand
- •Improves long-term speed by building debugging intuition
- 29:01 – 31:22
Design exploration on the subway: index-card prototypes → GPT-4 upscaling → Figma UI kit
Terry shows his low-tech-to-high-tech design pipeline: sketch screens on index cards when offline, photograph them, then use GPT-4 image capabilities to “upscale” into clearer mockups. He then moves designs into tools like UXPilot/Figma and uses Apple UI libraries to quickly assemble realistic iOS layouts.
- •Offline prototyping with index cards (mobile aspect ratio)
- •Upload sketches to GPT-4 to generate higher-fidelity variations
- •Transfer into Figma via tooling (e.g., UXPilot)
- •Leverage Apple UI kit/components for fast, native-feeling designs
- 31:22 – 32:28
Human creativity and the last 10%: where AI still struggles (especially in design)
Claire and Terry reflect on the gap between “80% good” AI outputs and the craft required to polish the final experience. They argue the differentiator is often the last 10%—interaction details, visual refinement, and product judgment—and side projects help PMs empathize with engineering/design tradeoffs.
- •LLMs often get you to 80% quickly; final polish is hardest
- •Design refinement and craft remain a key human advantage
- •Pragmatism: ship MVP, then iterate where it matters
- •Side projects improve PM communication with engineers/designers
- 32:28 – 35:21
Lightning round: mobile debugging asks, model quality, and Git-based risk control
Terry shares practical wishes for mobile AI tooling (better visibility into on-device behavior like network traffic), and comments on LLM code quality for mobile ecosystems. He also explains his main control mechanism: frequent Git commits to mitigate risk when the model drifts off track.
- •Tooling ask: better mobile observability (e.g., network inspection)
- •LLM quality: generally good; occasional issues with outdated patterns
- •Strategy when models drift: frequent Git commits and rollbacks
- •A disciplined, incremental approach vs “YOLO” large commits
- 35:21 – 36:16
Where to find Terry + closing wrap
Claire closes the episode with thanks and a call for viewers to like/subscribe and leave reviews. Terry shares where people can connect with him online.
- •Contact: Terry on LinkedIn and X
- •Episode wrap and audience calls-to-action
- •Podcast availability across platforms
