Back to database

Terry Lin's AI use case

Product manager and AI-assisted app builder at Cooper's Corner

Terry Lin built Cooper's Corner, a voice-powered Apple Watch and iPhone fitness app, by combining low-tech index-card prototyping with a structured AI coding workflow in Cursor and Xcode.

The problem

What was broken before AI

Workout logging at the gym was clunky: typing sets into an app, opening notes, or writing in a notebook interrupted the workout. Terry wanted a smoother way to speak a set aloud and have it become structured workout data across phone and watch. Before building the app, he also had to solve the usual mobile-development problem: AI coding tools are helpful, but iOS apps still need Xcode, simulators, device testing, and careful debugging.

What changed

What the use case made possible

AI let Terry bridge several gaps at once: voice transcription into structured exercise data, rough sketches into cleaner UI concepts, basic tickets into fuller PRDs, and PRDs into coded implementation plans. The workflow reduced the blank-page problem for design and engineering, while his review and commit process kept the AI from becoming an uncontrolled code generator.

Why this matters

Why this use case is worth studying

The most useful move is starting analog. Terry’s index cards gave him a cheap way to think through a mobile interface before touching a code editor, and that made the AI work downstream better. His engineering workflow also shows a mature habit: he asks AI to create plans, review its own clarity, execute in small phases, and explain the code back to him so he stays in control of the product.

Use this when

When this pattern applies

Use this when you have a product idea that starts as a physical or messy real-world behavior and you need a disciplined path from rough prototype to working app.

Exponential Builder analysis

01

Start where the model cannot help

the messy habit. Terry did the right first move by validating the spoken workout loop before building the app, because AI is much more useful once the behavior has been observed in the real world.

02

Make rough inputs respectable before making them permanent.

Index cards, voice memos, and spreadsheet outputs gave the AI concrete artifacts to transform, which reduces the chance of the model inventing a product around a vague intention.

03

Keep AI inside a build discipline.

The Cursor workflow works because it is paired with PRDs, review passes, Xcode testing, small commits, refactoring, and code explanation; the human remains responsible for what ships.

Who this is for

Best fit

Founders building an app prototype without a large engineering team

Product managers learning AI-assisted development

Designers who want to turn paper sketches into usable mobile mockups

Engineers using Cursor on native iOS or Apple Watch projects

Builders who want AI coding help without losing control of architecture and quality

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not skip the manual proof-of-concept; it prevents you from building a polished version of an unproven loop.

Do not let the AI write large changes without checkpoints, especially in mobile apps where build and runtime errors can hide in platform details.

Do not treat generated UI mockups as final design; check them against native platform conventions and real component libraries.

Do not accept AI-written code you cannot explain, maintain, or debug.

Be careful with health and fitness claims; workout logging is safer to describe as tracking and organization, not medical or professional training advice.

If voice data is stored or processed, think through privacy, consent, retention, and where transcription happens.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

01

Prove the behavior first

Use the simplest possible version of the workflow before building the full app.

02

Sketch the interface physically

Draw phone-sized screens on index cards to reason through the flow quickly.

03

Upscale the sketch

Photograph the card and use GPT-4 through ChatGPT to create a cleaner UI concept.

04

Move into design tools

Bring the generated image into UX Pilot and Figma, then align it with native iOS components.

05

Code with guardrails

Use Cursor for AI-assisted coding and Xcode for building, debugging, and device testing.

06

Review before execution

Turn tickets into PRDs, have AI critique the PRD, then execute in small committed phases.

Copy the pattern

The reusable idea

Pattern in one sentence

Turn the real-world behavior into a cheap manual prototype, make the interface tangible on paper, then use AI to convert clearer inputs into mockups, specs, and small reviewed code changes.

Reusable idea

If you are building with AI, copy the order of operations more than the exact tools. Start with a cheap prototype, make the desired behavior concrete, turn that into a written spec, and only then ask AI to help code. Terry’s workflow works because it gives the model smaller, clearer jobs instead of asking it to infer the whole product from a vague idea.

Steal this workflow

Use Terry’s “rough loop to guarded build” sequence:

1

Pick one annoying repeated action, such as logging a workout set mid-session.

2

Test the core loop with existing tools: capture a real input, convert it into structured data, and check whether the output is actually useful.

3

Sketch the first screens on index cards before opening a design or code tool.

4

Photograph the sketch and ask AI to turn it into a cleaner iOS-style mockup while preserving the layout and intent.

5

Turn one feature ticket into a short PRD with goals, acceptance criteria, user stories, and edge cases.

6

Ask a second AI pass to critique the PRD for missing context, ambiguity, and execution risk.

7

In Cursor, break the PRD into small implementation phases.

8

After each phase, build and test in Xcode, then commit before moving on.

9

Refactor large files into smaller pieces so future AI edits stay easier to review.

10

Ask AI to explain the new code back to you and quiz you on the data flow before accepting the work.

Suggested prompt

“I’m building a native Apple Watch/iPhone feature for [specific user action]. Here is the product ticket, rough workflow, and any sketch notes: [paste details]. First, expand this into a concise PRD with goals, non-goals, user stories in Given-When-Then format, acceptance criteria, edge cases, and platform considerations for iOS/watchOS. Then critique the PRD as if another model had to implement it with no extra context: rate it out of 10 and list what is missing, ambiguous, or risky. After that, break the approved PRD into small implementation phases. For each phase, describe the files likely to change, the test/build checks to run in Xcode, and the git commit message. Stop after each phase for review.”

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

No spam. Just useful AI use cases.

Related use cases

Keep exploring nearby systems.

Browse all