Every lesson before this one deliberately isolated one link of the chain, because a single unfamiliar skill is hard enough to learn without seven others running at the same time. That isolation was pedagogically necessary and it was also artificial — no real case arrives pre-sorted into "differential-building" and "bias-auditing" phases. This lesson removes the scaffolding and runs the whole thing: intake, differential, bias check, advocate translation, population context where relevant, a safety pass, and a calibrated confidence report, on one case, in the order a real case actually demands them.
The VibeRounds Master Protocol is the module that stitches the others together — not new content, but an explicit sequencing of when to invoke which prior module, and what to carry forward from each step into the next. Module 50 supplies the closing move: after the protocol finishes, read back the full trace as a single artifact and ask whether it holds together as a defensible piece of reasoning, not just whether the final answer sounds right.
This is the difference between knowing eight individual techniques and knowing when to reach for each one, in what order, on a case that doesn't announce which phase it's in. That judgment is the actual skill this course has been building toward.
This is the difference between unit tests for eight individual functions and an end-to-end integration trace — each function can pass its own test in isolation and the pipeline can still fail at the seams, which is exactly what running the full protocol on one case is designed to catch.
The Shape of the Master Protocol
The Master Protocol is not a ninth technique to learn — it's a sequencing decision layered on top of everything already covered. Given a real case, it specifies an order: build the differential first (Lesson 3), because nothing downstream means much without one; run the bias audit against that differential before acting on it (Lesson 4), because an unaudited differential is exactly the kind of confident-looking output the rest of the protocol depends on being trustworthy; branch into advocate translation and population context only where the case actually calls for them (Lessons 5 and 6, invoked conditionally rather than always); run a safety pass if the case involves a process with real failure modes (Lesson 7); and close with a calibrated, multi-domain confidence report, shadow-reviewed before it's finalized (Lesson 8).
The protocol's own instruction on sequencing is worth stating plainly, because skipping steps under time pressure is the single most common way the protocol gets used badly:
The instinct to skip the audit step precisely when a case "feels obvious" is the instinct the whole course has been training you to notice and override — obviousness is a feeling, not evidence that the reasoning underneath it is sound.
This is a fixed pipeline order with conditional branches — some stages always run, some run only if a feature flag (does this case involve an advocate, a population question, a hazardous process) is set — the same shape as a CI pipeline with required and optional stages.
Running It: A Worked Case
Take a case carried through this course: a patient presenting with a symptom cluster ambiguous enough to need a real differential. The trace runs as follows — Lesson 3's differential-building surfaces three to five candidates with likelihood ratios attached; Lesson 4's bias audit flags that two of the candidates share a feature the reasoner may be over-weighting because it matches a recently-seen case; Lesson 5's advocate brief is invoked because the patient's daughter will be the one relaying information to a second opinion; Lesson 6 is skipped, correctly, because this case doesn't raise a population-level question; Lesson 7's FMEA runs against the medication plan because a new drug is being added to an existing regimen; and Lesson 8 closes with a three-domain confidence report — strong evidence, moderate applicability given the patient's age, and a reasoning chain the shadow review flags as slightly overconfident on the second-ranked diagnosis.
What makes this a genuine "start to finish" exercise rather than a checklist is that each stage's output becomes the next stage's input — the bias-audited differential, not the raw one, is what gets translated into the advocate brief; the FMEA's highest-risk step, not every step, is what the confidence report needs to speak to.
This is what a genuinely thorough case work-up looks like when written down in full — not more steps than most careful clinicians already do intuitively, but each step made explicit enough to hand to a colleague, a student, or a review board.
This is a directed acyclic graph of stages, not a flat list — each node consumes the previous node's output rather than the raw input, which is exactly the difference between a real pipeline and eight independent scripts run in sequence.
Reading Your Own Trace: Module 50
Module 50 is the course's final move, and it inverts the direction of everything before it: instead of producing the reasoning, the task is to read it back — the full record of differential, audit, advocacy, analytics, safety, and calibration — as a single artifact, and evaluate whether it holds together end to end. This is the trace itself as the object of scrutiny, not just the final recommendation it produced.
That question — did a later stage ever force a genuine revision of an earlier one — is the single best test of whether the protocol was actually followed as a connected process, or merely performed as eight disconnected exercises stapled together in the right order.
The best case reviews aren't graded on whether the final diagnosis was right — they're graded on whether the reasoning that got there would survive being read back a week later by someone who wasn't in the room.
This is an end-to-end request trace, read back after the fact — the same discipline as reviewing a full distributed trace across a pipeline's stages instead of just checking that the final response code was 200, because the interesting failures live in the seams between stages, not in any single stage's isolated output.
Final Exercise: The Full Trace
- Take the case you've carried since Lesson 2 and write its full trace in one document, in protocol order: differential (Lesson 3), bias audit (Lesson 4), advocate brief if relevant (Lesson 5), population framing if relevant (Lesson 6), a safety pass on any process step involved (Lesson 7), and a three-domain confidence report, shadow-reviewed (Lesson 8).
- Run Module 50's full-trace review on what you just wrote: find one point where a later stage should have forced a revision of an earlier one, and state what that revision would be.
- Read the trace once more as if you were a colleague seeing it cold, with no memory of writing it. Would it hold up? Name the one part you'd want strengthened before handing it to someone else.
This lesson draws directly on the VibeRounds Master Protocol and Module 50 — Full-Trace Retrospective Review, both from the VibeRounds Prompt Directory. This lesson doesn't introduce new technique — it's the other eight core lessons run in sequence on one case, which is also the best way to reread them if anything above felt disconnected the first time through. The companion Evidence-Based Medicine for Techies course has its own closing case-based lesson and is worth reading alongside this one. Neither course is a clinical decision tool; see the VibeRounds disclosure statement for full terms.