Ask a clinician how they reached a diagnosis, and most will describe the conclusion fluently and the path to it hazily — a blur of "it just fit" and "something felt off." That blur is not sloppiness. It's the normal, mostly-invisible nature of expert cognition: pattern recognition compresses years of exposure into a near-instant judgment, and the compression is exactly what makes the underlying steps hard to narrate afterward.
This course is about making that process visible — not to replace it with an algorithm, but so it can be examined, taught, and improved. That's what we mean by clinical cognition: not the diagnosis itself, but the sequence of noticing, hypothesizing, weighing, doubting, and deciding that produces it.
You already do this. The goal here isn't to learn a new skill from scratch — it's to give a name and a structure to something you do intuitively, so it can be rehearsed deliberately instead of only absorbed by osmosis on the wards.
Think of a diagnosis as a model's output, and clinical cognition as the reasoning trace behind it — the intermediate steps a chain-of-thought log would show. Most clinical training never captures that trace. This course is partly about building the habit of capturing it.
Why the Process Stays Hidden
Three forces keep clinical reasoning invisible in ordinary practice:
- Expertise compresses itself. As a clinician becomes more experienced, conscious step-by-step reasoning gives way to fast pattern recognition — useful for speed, costly for teachability. The expert often can't fully reconstruct why they knew.
- Time pressure discourages narration. A ward round has no slot for "let me think out loud for four minutes." The conclusion gets documented; the reasoning that produced it usually doesn't.
- Training rewards the answer, not the path. Exams grade the final diagnosis. A learner who reaches the right answer through a lucky guess and one who reaches it through sound reasoning both get full marks — so the incentive to narrate the path is weak.
Worked Example: The Same Case, Two Ways
Here is one finding, presented first as a conclusion only, then with the reasoning trace exposed.
54F, sudden right-sided pleuritic chest pain and shortness of breath after a long-haul flight. HR 112, O₂ sat 92%. Working diagnosis: pulmonary embolism. CTPA ordered.
Same findings. Long flight and pleuritic pain pull toward PE — the classic pattern. But before committing: what single finding would make me regret starting anticoagulation? A widened mediastinum on chest X-ray would point to aortic dissection instead, and starting anticoagulation on a dissection is catastrophic rather than merely wrong. So the pre-test step isn't "confirm PE" — it's "actively rule out the diagnosis where I'd be most harmed by being wrong first."
Version A is what ends up in most notes. Version B is what clinical cognition training tries to surface and rehearse — not because Version A's diagnosis is wrong, but because the discipline in Version B (checking the highest-stakes alternative before committing) is a transferable skill, while a correct diagnosis in isolation teaches almost nothing about the next case.
This is the "what would kill the patient if I'm wrong" check — a pre-mortem run before the decision, not after. It's a habit, not a formula, and it's exactly what Version A's note-writing convention erases.
Version A is the model's final output token. Version B is the reasoning trace. If you've ever debugged a system by only reading its final log line, you already know why the trace matters more than the answer when something goes wrong.
The Basic Loop
Across the VibeRounds module set, one shape recurs regardless of specialty or case complexity — a loop, not a straight line:
| Stage | What happens | Where it can fail |
|---|---|---|
| Observation | Raw findings are gathered — history, exam, early data. | Anchoring on the first plausible story before the data is complete. |
| Pattern recognition | Findings cluster into a recognizable illness script. | Overfitting to the most memorable recent case, not the most likely one. |
| Hypothesis generation | A working differential forms, ranked by likelihood and by stakes. | Ranking by likelihood alone and ignoring what's most dangerous to miss. |
| Testing & revision | New data confirms, narrows, or overturns the leading hypothesis. | Seeking only confirming evidence (confirmation bias). |
| Commitment | A decision is made under whatever uncertainty remains. | Waiting for false certainty that will never arrive, delaying care. |
| Reflection | After the fact: what was learned, what pattern will transfer to the next case. | Skipped almost universally — the step this course spends the most effort rebuilding. |
The rest of this course is organized around this loop: Lessons 2–3 go deeper into observation, pattern recognition, and hypothesis generation; Lesson 4 is entirely about where the loop breaks (bias); Lessons 5–6 apply the loop outside the single-clinician case (advocacy, registries); Lesson 7 asks what happens when the loop fails at a systems level; Lesson 8 is about calibrating confidence honestly at each stage; Lesson 9 runs the whole loop, once, start to finish, on a full case.
A First Taste: Questioning Instead of Answering
One deliberate design choice recurs throughout the module set: the AI is instructed not to hand over a diagnosis, but to ask the question that would make the reasoning visible. Below is the actual opening instruction used to start a Socratic session (Module 1, Step 1.0) — read it once for the content, and once for what it's designed to prevent.
A learner who is handed the answer never has to build — or expose — their own reasoning path. Withholding forces the trace from Version B above to actually happen, instead of staying hidden the way it does in a normal note.
This is a guardrail against a specific failure mode: a too-helpful model filling silence the moment a user types "idk." It's the same principle as forcing a commit before a code review can proceed — the review is worthless if there's nothing committed to review yet.
We'll go deep on this mechanism — and the full ten-point constraint set behind it — in Lesson 2. For now, the takeaway is narrower: a Socratic question is a tool for forcing the reasoning trace into the open, the same trace we manually exposed by hand in Version B above.
Two Threads We'll Carry for the Whole Course
Two more modules belong here, in Lesson 1, even though their full payoff doesn't arrive until much later — because both describe habits you should start practicing from the very first case, not techniques you bolt on afterward.
Module 31 — self-assessed calibration is the discipline of attaching an honest confidence label to a judgment at the moment you make it, not retrospectively once you already know whether you were right. A clinician who says "I'm 60% on this and here's what would change my mind" before the result comes back is doing something categorically different from one who only ever describes their confidence after the fact, when hindsight quietly inflates it. We'll build a full multi-domain version of this in Lesson 8; the version to start practicing now is just the single-number habit — attach a number, then check it.
Module 57 — the capstone loop is the module that eventually stitches every other module together into one end-to-end pass over a real case. It doesn't have content of its own in the sense the others do; its job is to specify the order in which everything else in this course gets invoked. We mention it here, at the very start, so the six-stage loop above doesn't read as a closed system — it's the first draft of what Module 57 will later run in full.
Start narrating a confidence number out loud on your next few cases, before you know the outcome — not for anyone else's benefit, just so you can check your own calibration against reality later.
Module 31 is a confidence score logged at inference time, not computed retroactively from the eval set. Module 57 is the orchestrator that will eventually call every other module in sequence — think of it as the pipeline definition file we haven't written yet.
Homework for Lesson 1
- Pick one recent case you were involved in (your own patient, a case report, or a case from the news) where you reached a conclusion. Write the "Version A" one-paragraph conclusion, the way it might appear in a note.
- Now write a "Version B" for the same case: what was the single highest-stakes alternative you (or the clinician) should have actively ruled out before committing? What one question would have forced that check into the open?
- Using the six-stage loop above, mark which stage your case moved through fastest, and which stage — if any — was skipped entirely. Bring this case forward; we'll return to it in Lesson 3 when we build a full differential from scratch.
This lesson draws directly on Module 1 — Socratic Clinical Reasoning, the Module 0 / Module 32 orientation and cognition-loop concepts, Module 31's self-assessed calibration habit, and Module 57's capstone-loop framing, all from the VibeRounds Prompt Directory. If you're coming from the evidence side rather than the reasoning side, the companion Evidence-Based Medicine for Techies course — see especially Lesson 3, on appraising an RCT — pairs well with this course: EBM asks "can I trust this evidence," while this course asks "how did I get from findings to a judgment in the first place." Neither course is a clinical decision tool; see the VibeRounds disclosure statement for full terms.