HeyDoctor: Clinical Cases

A daily reasoning game for med students and clinicians, scored like a real consultation. One new patient every day. Interview them, order real tests, commit to a diagnosis.

Comment

Inspiration

In 2017, I built Ammesso, an app that helped more than 150,000 Italian students prepare for university entrance exams. Many of them were trying to get into medical school. It reached #1 in Education on the Italian App Store, was featured by Apple three years in a row, and was acquired in 2021.

Then something interesting happened. I kept talking to the students who had made it into medicine, and years later I would hear variations of the same problem: you can spend six years learning an enormous amount of medicine and still feel unprepared the first time a real patient sits in front of you.

That's because a patient does not hand you five options. They say: “My chest hurts.” And then they look at you. HeyDoctor is the app I wish those students had after they passed the medical admission test. It is a daily clinical reasoning game: one new patient every day. The same case for everyone in the world. You interview the patient, decide what to investigate, commit to a diagnosis, and see how efficiently you reasoned.

All in about five to ten minutes.

What it does

HeyDoctor turns clinical reasoning into a daily habit. Every case follows the same loop:

  • Talk to the patient. Ask anything in plain language. The AI patient answers like a person: symptoms, worries, half-remembered details, small talk. They know what they feel, not what they have, and they never volunteer the clue you forgot to ask for.
  • Order investigations. Physical exams, blood work, ECGs, imaging, biopsies and more. Every result comes from the case file, never from the language model. Ask for the same troponin twice and you get the same troponin twice.
  • Make the diagnosis. Search across 1,100+ conditions spanning 20 specialties. You get three attempts.
  • Get scored on your reasoning. Every question and investigation has a cost. A message costs 10 points. Tests cost between 15 and 100 depending on the decision. A wrong diagnosis costs 150. The correct diagnosis earns 200 back.

The goal is to ask the right questions, order the right tests, and know when you have enough information to commit. Fewer unnecessary steps, higher score. Around that core loop are streaks, XP, achievements, a global leaderboard, and spoiler-free result cards players can share after finishing a case.

Free players get one full case each week. HeyDoctor Pro unlocks a new case every day and the full case archive. The daily format is deliberate: the product is not meant to become another 40-hour medical course sitting unfinished in somebody's library. It is meant to become a five-minute ritual.

How I built it

HeyDoctor started with a simple observation: clinical reasoning is not about recognizing the right answer. It is about figuring out what to ask next. I wanted to know if that could become a game.

So I wrote a rough PRD describing the smallest possible version of the experience and started building with Claude Code (Fable 5). By the morning, I had a web prototype with two hardcoded cases and a chat interface. I wanted to test just one thing: does talking to an AI patient actually make you reason like a clinician?

I gave it to medical students almost immediately. That changed the product.

They started competing over who could solve a case with fewer questions and fewer tests before I had even designed the competitive layer. They also found the first major flaw: the AI patient was too helpful. It gave clean, complete answers and sometimes made the diagnosis obvious. So I made the patient less like a textbook and more like a person: vague, selective, occasionally focused on the wrong detail.

From there, the prototype slowly turned into a system.

I built scoring around efficiency, a catalogue of 1,100+ diagnoses, investigations with different costs, streaks, XP and leaderboards. Then I built the less visible half of the product: structured clinical case documents, deterministic investigation results, a case-generation pipeline, review workflows and an admin panel for scheduling and quality control.

The principle that emerged through all of this became the architecture of HeyDoctor: the AI can make the patient feel alive, but it never gets to decide what is medically true.

I built the whole product as a solo founder, using AI not just inside HeyDoctor, but as part of the development process itself. That compressed the distance between an idea, something I could put in front of a user, and the next iteration to hours instead of weeks. The first version came together remarkably fast.

Tech Stack

Tech stack, in one breath. Two codebases, one backend. The iOS app is Expo and React Native on the new architecture. Every screen calls the same API as the web app. The web app is Next.js 16 on Vercel with Tailwind 4, and it also hosts the admin backoffice and every /api/* route. Data and auth are Supabase (Postgres with RLS, Auth, Storage), shared by both clients. AI is Anthropic end to end: Claude Sonnet plays the patient, streaming; Claude Fable 5 generates cases in a multi-agent pipeline with Claude Opus 5 as fallback; OpenAI covers ECG images and the chat fallback. Every case is a Zod-validated Clinical Case Document, and investigation results are read from it, never generated at play time. Monetization is RevenueCat in the app (SDK, Paywalls, Customer Center, one "HeyDoctor Pro" entitlement) and soon to be on the web (I've used Stripe with the web MVP), both syncing through webhooks into the same billing tables. Rate limiting on Upstash, captcha with Cloudflare Turnstile, builds with EAS, cron jobs on Vercel. Built solo.

Challenges I ran into

Building a case every day

A daily game has an awkward requirement: you need something good to play tomorrow. And the day after that. And the day after that. In multiple languages. Forever.

My first approach was basically “write me a clinical case.” It failed spectacularly.

Histories contradicted laboratory results. Findings pointed toward diagnoses that were not the answer. Patients occasionally leaked the diagnosis during conversation. Some cases were medically plausible but terrible games.

So I built a case-generation pipeline instead. An anchor agent establishes the diagnosis and patient. Specialized agents build individual parts of the case. A critic checks coherence, information leakage, clinical consistency and safety. Sections that fail are regenerated or patched before the case can move forward.

Cases are generated as multilingual families, so the English and Italian versions represent the same patient and can share one global leaderboard. An automated scheduler keeps upcoming days populated.

Making patients sound like patients

Early versions said things like: “I present with retrosternal chest pain radiating to my left arm.” Nobody says that to their doctor. The hard part was getting a worried 58-year-old to say something closer to: “I thought it was indigestion, but it isn't going away.” That required repeated changes to both the case representation and patient prompt.

Accomplishments that we're proud of

I'm proud that HeyDoctor is not simply “ChatGPT /Claude pretending to be a patient.” There is a real game underneath it. A structured case system. A scoring economy. A deterministic diagnosis engine. A content pipeline. A review workflow. A global daily challenge. And a business model designed around turning practice into a habit.

Most of all, I am proud of these:

  • A patient you can genuinely interview in free text.
  • Investigation results that cannot be hallucinated at play time.
  • A scoring model that rewards reasoning rather than test-ordering reflexes.
  • More than 1,100 diagnosable conditions across 20 specialties.
  • One clinical case shared globally every day.
  • A pipeline capable of continuously generating future cases.
  • One backend shared between web and native.
  • Cost efficiency: case generation costs $0.45 average, user sessions cost $0.03 average. So the business model is working fine.

What I learned

The biggest lesson was this: In AI products, some of the most important engineering decisions are about what you refuse to let the model do.

I also learned that a daily format is not really a content strategy. It is a retention strategy. The case is the content. The ritual is the product. And building for clinicians raises the bar enormously. They notice when terminology is wrong. They notice when a test is unrealistic. They notice when an AI gives information it should not know.

That pressure made HeyDoctor better.

Finally: RevenueCat Paywalls saved me days I did not have. When you are building alone, with an App Store deadline and a newborn in the house, infrastructure you do not need to build yourself becomes very, very valuable.

What's next for HeyDoctor: Clinical Cases

The first goal is to make the daily loop better. More cases. Better feedback. Better explanations. Better ways to understand how you reasoned, not just whether you got the diagnosis right.

Next I want to add:

  • Specialty tracks, with separate progression and leaderboards.
  • A weekly reasoning report showing patterns such as over-ordering, premature closure and unnecessary questions.
  • More languages, building on the same shared case families.
  • And eventually, HeyDoctor for medical schools and residency programs: cohorts playing the same cases, faculty seeing aggregate reasoning patterns, and clinical reasoning becoming something students can practise repeatedly rather than something educators only observe occasionally.

P.s. Sorry, I used AI to translate the content because English isn't my main language.

Built With

Share this project:

Updates

Submission history