[Prompt]
custom: Yesterday my wife and son had to go to the urgent care. We've been through this rigmarole a few time | Hosts: corn, herman

[Response]
Corn: Most people assume the big colorful buttons at the urgent care are covering for a dumb system. Like the screen is simple because the software underneath can't handle anything more complicated. That's backwards. The screen is simple because the person using it is holding a screaming toddler and a blood pressure cuff at the same time. The sophistication is somewhere else entirely.

Herman: And the thing that's actually sophisticated is the part Daniel couldn't see.

Corn: Right. So Daniel wrote in this week. His wife Hannah and his son Ezra ended up at urgent care, bad stomach bug, Hannah needed an IV, and they've done this run a few times lately. While they're waiting, Daniel's facing the monitor, and he watches the tech work this screen. Big buttons, huge text, color everywhere. The tech's punching in vitals as he takes them. And then Daniel notices it's a two-way system. He's putting in emojis for how Ezra's doing, and the system is talking back. Prompts like, check if the patient vomited in the last three hours. And then, order IV.

Herman: Order IV is the one that got me.

Corn: Yeah. So Daniel wants to know what class of software that actually is. Not the intake layer, not the registration and insurance side. The triage support system underneath. Who makes it, where is it quietly deployed. And the big one: is this mostly rule-based, traditional decision trees and flowcharts, or is reasoning-based AI already running in there, semantically understanding the patient? And if AI is running, what diagnostic support model would you actually expect in deployment for this kind of workload? Plus the medical calculators, the IV dosing off patient size and age.

Herman: There's a lot in there.

Corn: So let's start with what he was actually looking at.

Herman: Two distinct software classes stacked on top of each other. The first is a triage module inside an Electronic Health Record. The second is a Clinical Decision Support System sitting on top of it. The EHR is the record. The CDSS is the brain that reads what's in the record and suggests what to do next.

Corn: And Daniel already drew the line himself, which I appreciated. He said, not the patient information intake layer. Intake is demographics, insurance, chief complaint. That's administrative. It's billing-adjacent. The triage layer is structured clinical assessment. Acuity scoring. Order prompts. Dose calculation.

Herman: Intake asks who is this and who's paying. Triage asks how sick is this and what do we do in the next ten minutes. Completely different software, often from different vendors, sometimes barely talking to each other.

Corn: The UI though. Daniel said it was impossible to ignore. Massive text, color coding, big buttons.

Herman: That's deliberate. High cognitive load, time pressure, a tech entering vitals one-handed while managing a patient. You want glanceability and you want touch targets big enough to hit without looking. The color coding isn't decoration, it's a status channel. Green, yellow, red, you read it in your peripheral vision.

Corn: But here's the twist we keep coming back to. That old-school look is also often old infrastructure. Both things are true at once. It's a deliberate design choice layered over a codebase that might be fifteen years old.

Herman: Sometimes older.

Corn: So what's actually running underneath that screen?

Herman: The two frameworks that matter. Emergency Severity Index, ESI. That's the standard in most U.S. emergency departments. Five levels, explicit decision points. You check danger-zone vitals first, that's level one or two territory. Then you predict resource needs to sort the lower levels.

Corn: And the second one?

Herman: Manchester Triage System. Widely used globally. Built on structured flowcharts and what they call discriminators. A discriminator is a specific finding that pushes you down a particular branch of the flowchart.

Corn: So when Daniel sees a prompt asking whether the patient vomited in the last three hours, that's not the system being clever. That's a node in a decision tree.

Herman: Exactly that. You're at a branch. The branch has a question attached. The question gets surfaced to the human. The human answers, and the answer determines which branch you go down next. That's what a flowchart is when you make it executable.

Corn: Which is the thing about static flowcharts. On paper they're just diagrams. Running, they're the actual protocol.

Herman: And the evidence that this is rule-based under the hood is pretty striking. There's a study from 2018, Dehghani Soufi and colleagues in the International Journal of Medical Informatics. They built a triage decision support system modeling the ESI algorithm's first four decision points. Rule-based reasoning plus fuzzy logic.

Corn: How many rules did they need?

Herman: Fourteen rule-based rules. Twenty-seven fuzzy rules. That's it. Forty-one rules total.

Corn: For a system that's sorting human beings by how close to death they are.

Herman: And they hit 99.44 percent accuracy against the reference standard. Mis-triage dropped from 13.4 percent down to near zero. Documentation completeness went from 76.7 percent to 98.5 percent.

Corn: Hold on. Say that mis-triage number again.

Herman: 13.4 percent down to near zero.

Corn: So the baseline, humans doing this without the system, got it wrong about one time in seven. And forty-one explicit rules beat that.

Herman: That's the part people don't expect. The sophisticated backend Daniel intuited is real, but it's mostly explicit decision trees and protocol rules. It's not reasoning. It's a very well-organized checklist that never gets tired and never forgets to ask the question.

Corn: Let me push on that, because "checklist" undersells it. A checklist is something you can ignore. What you're describing sounds more like a checklist that's wired into the workflow so you can't skip a step. Is that the right way to think about it?

Herman: That's closer. The rule engine is enforcing the sequence. If the danger-zone vitals come back abnormal, the system doesn't let you wander off into the resource-prediction branch. It routes you. The human can override, but the override is logged, and the log is auditable. So the checklist has teeth.

Corn: And the teeth are the point. The 13.4 percent baseline failure rate wasn't because nurses were careless. It was because humans under time pressure skip steps. The system doesn't skip steps.

Herman: It doesn't get interrupted. It doesn't get called away to another bay. It doesn't have a bad night.

Corn: Okay, the Manchester side. You said it shows where rules break down.

Herman: There was a narrative review this year, Zaloznik Djordjevic and colleagues in Healthcare, confirming MTS is flowchart-driven. But they flag known inter-rater variability. Subjectivity in how the discriminator gets selected.

Corn: The rules are only as good as the human picking the branch. Two nurses look at the same patient, one picks this discriminator, one picks that one, and they land on different acuity levels.

Herman: Right. And the flowchart can't resolve that, because the flowchart doesn't know which discriminator is correct. It just executes whatever branch it's handed.

Corn: So the flowchart doesn't remove judgment. It structures it.

Herman: Structures it and documents it. Which is a real gain. But it doesn't eliminate the human variable.

Corn: Give me a concrete version of that. What does inter-rater variability actually look like at the bedside?

Herman: Classic example is a patient who's breathing a little fast but otherwise looks okay. One nurse reads that respiratory rate as a discriminator that pushes toward a higher acuity. Another nurse reads it as anxiety, or as the patient having just walked in from the parking lot, and stays on the lower branch. Same number on the vitals monitor. Two different triage levels. And the flowchart can't adjudicate it, because the disagreement is upstream of the flowchart.

Corn: So the system is only as consistent as the humans feeding it.

Herman: Which is exactly why the rule-based systems still beat the humans on the aggregate. The rules don't fix the input problem, but they do catch the missed steps. That's where the 13.4 percent number comes from.

Corn: Now the medical calculators. Daniel specifically asked about IV dosages off patient size and age.

Herman: Weight-based pediatric dosing is the classic CDSS function. It's a deterministic calculator. You take the patient's weight, you take the age, you compute milligrams per kilogram, and you apply hard-coded safety ceilings.

Corn: Hard-coded ceilings meaning what, exactly?

Herman: Meaning there's a maximum dose baked into the logic that no input can exceed. If somebody fat-fingers the weight and types in a hundred kilograms for a nine-kilogram infant, the calculator refuses to produce a lethal number. It caps.

Corn: That's the guardrail.

Herman: And this is the part that matters for the AI question. Weight-based dosing is arithmetic with safety limits. It is never left to a generative model in production. Ever. You do not want a system that might round creatively when the output is how much drug goes into a small child.

Corn: So the ceiling isn't a suggestion. It's a hard stop.

Herman: Hard stop. The calculator will not output a number above the ceiling. It's not a warning you can click past. It's a wall.

Corn: And the age input, why does age matter separately from weight?

Herman: Because some drugs have age-based ceilings independent of weight. Neonates and infants metabolize differently. So the logic is looking at both dimensions. Weight gives you the mg per kg. Age gives you the ceiling and sometimes the formulation. A two-year-old and a twelve-year-old at the same weight don't necessarily get the same dose of everything.

Corn: So it's two-dimensional arithmetic with guardrails on both axes.

Herman: Two-dimensional arithmetic with guardrails on both axes. And none of it is probabilistic. Every output is reproducible. You put in the same weight and age, you get the same number, every time, forever.

Corn: The Order IV prompt then. That's an order set?

Herman: Likely an order set triggered by protocol logic. Dehydration criteria, severity markers, whatever the local protocol says. The system recognizes the pattern and surfaces the order. The dose gets auto-calculated from the recorded weight. The human still has to sign it.

Corn: So the whole chain is: structured input, rule evaluation, prompt to human, human decides, calculator computes, human signs.

Herman: And every step is auditable. That's the thing. You can point at any decision and say, this rule fired because this value was entered. Try doing that with a neural network.

Corn: There's a caveat though. You mentioned the 2024 scoping review.

Herman: Michel and colleagues, International Journal of Medical Informatics. They looked at nineteen triage CDSS. Only three of the nineteen were actually connected to the EHR.

Corn: Three out of nineteen.

Herman: Three. So the sophisticated backend is often less integrated than it looks. A lot of these systems are standalone. Somebody's entering data twice, or the triage tool lives in a separate window and the nurse is copy-pasting.

Corn: Which brings us back to the UI. If the system isn't integrated, the big buttons might be the only thing holding the workflow together.

Herman: The interface is doing labor the integration should be doing.

Corn: That's the mechanism. But who actually makes this stuff, and where does it live?

Herman: Epic Systems and Oracle Cerner dominate the large hospitals and academic centers. If Daniel was at a big health system, the odds are good it was one of those two. Their triage modules, their Best Practice Advisories, their order sets.

Corn: Best Practice Advisories. That's the pop-up that tells you to do something.

Herman: That's the pop-up. And it's rule-based. It's an if-then. If these conditions are met, surface this advisory. The advisory Daniel saw about vomiting in the last three hours is that pattern exactly.

Corn: There's also a newer category. EHR-agnostic CDSS platforms.

Herman: EvidencePoint is the example that comes up. Cloud-based, described in a 2023 paper by Solomon and colleagues in JMIR Formative Research. The idea is to decouple the decision tool from any single EHR so it can plug into whatever the hospital already runs.

Corn: That's the sensible architecture. Whether it's winning, I don't know.

Herman: It's emerging. The installed base is still Epic and Cerner.

Corn: Now the deployment reality, because this is where it gets bleak.

Herman: Practitioner commentary on this is blunt. There's a line from a resident physician that I keep thinking about. Most EMR software is a billing system with record keeping attached.

Corn: Ouch.

Herman: And the purchasing pattern backs it up. These systems get bought by administrators with limited clinician input. Heavily customized per client. Often running on software that's ten or more years old. Updates might ship monthly, or less.

Corn: Which explains the aesthetic. The old-school look isn't only a design choice. It's also a codebase.

Herman: Both. The big buttons are deliberate. The fact that the underlying system was built in an era when the big buttons weren't deliberate is also real.

Corn: So now the AI question. Daniel asked it directly. Is reasoning-based AI already running in these systems to semantically understand patient data?

Herman: In production today, overwhelmingly no. It's rule-based. The 2024 review found nineteen triage CDSS, twelve knowledge-based, meaning guideline or expert algorithms, and only seven data-driven, meaning machine learning or deep learning.

Corn: Twelve to seven.

Herman: And the prompts Daniel saw are classic deterministic protocol logic. Same category as sepsis advisories and order sets. If-then rules. Not generative reasoning.

Corn: But the frontier is moving.

Herman: The frontier is moving fast. There's a 2026 scoping review, Hikmat and colleagues in Clinical and Experimental Emergency Medicine, that mapped twenty-seven studies using machine learning, deep learning, natural language processing, and large language models for acuity classification, sepsis detection, and flow optimization.

Corn: So people are trying.

Herman: People are trying hard. But the real-world performance numbers are sobering. Lee and colleagues in BMC Emergency Medicine, 2025, tested GPT-4o, Gemini 2.5, and DeepSeek on one thousand and fifty-seven real triage conversations.

Corn: Real conversations, not synthetic cases.

Herman: Real ones. Best accuracy was about 73.8 percent. That was Gemini 2.5 Flash. And there were sensitivity and specificity tradeoffs underneath that headline number.

Corn: Seventy-three point eight percent. On a task where the failure mode is missing the sick patient.

Herman: It gets worse. Lafuente and Rahim, 2025, found the best LLM F1 score below 0.60 on ESI prediction. Their conclusion was that LLMs work better as feature generators for machine learning models than as standalone decision-makers.

Corn: Feature generators. Meaning they extract the signal and hand it to something else.

Herman: And there's a tendency to over-triage. Haim and colleagues in the Journal of Clinical Nursing found GPT-4 assigns higher acuity than nurses do. Which sounds safe, but it's not, because over-triage clogs the system and burns resources on people who don't need them.

Corn: So the model errs toward caution, and the caution itself becomes the failure pattern.

Herman: And in a busy ED, over-triage is a real harm. The patient who didn't need the bed is now occupying it. The sick patient behind them is waiting longer. The false alarm isn't free just because it's on the safe side.

Corn: So if AI is being used, what would actually be running in deployment? Not the pilot, the deployment.

Herman: The emerging consensus is hybrid. Four layers, roughly.

Corn: Go.

Herman: Layer one, deterministic rule engine. Protocol logic, order sets, dose calculation. That's the must-not-miss safety layer. It doesn't get to be probabilistic.

Corn: Layer two?

Herman: Structured machine learning for risk prediction. XGBoost, gradient boosting, temporal transformers. There's a federated learning plus knowledge graph plus temporal transformer model that hit an AUC of 0.956 on MIMIC-IV and eICU data.

Corn: AUC 0.956 is a real number.

Herman: It's a strong number. For sepsis early warning, that's the kind of performance that gets attention.

Corn: And AUC, just to define it for people who haven't lived in this world, is a measure of how well the model separates the sick from the not-sick across every possible threshold.

Herman: Right. 0.5 is a coin flip. 1.0 is perfect. 0.956 is very good. It's not perfect, and it's not a diagnosis. It's a risk score that tells you where to look.

Corn: Layer three?

Herman: LLM as interface, not oracle. The ClaMPAPP pediatric appendicitis system is the clean example. The LLM extracts structured features from free text, and then passes them to a deterministic XGBoost classifier. The LLM reads. The classifier decides.

Corn: That's the pattern. LLM as interpreter.

Herman: And layer four, retrieval grounding. MECR-RAG grounds the LLM's triage output in actual guidelines and real cases to reduce hallucination. You constrain what it's allowed to draw on.

Corn: So the honest answer to Daniel's question is: the deployed reality is hybrid. Rules for safety, ML for risk scoring, LLMs as interfaces and feature extractors.

Herman: Never the LLM as the autonomous decision-maker.

Corn: There's a paper that makes the safety case better than I could. Sivanathan and colleagues, this year. They argue LLMs are not yet safe for autonomous triage. And the reason is interesting. It's not that they lack medical knowledge.

Herman: It's that they fail to gather information under uncertainty. They don't broaden the differential. They don't go looking for the missing red flag. They answer the question they were asked instead of the question they should have asked.

Corn: Which is the opposite of what a good triage nurse does.

Herman: And the line from that paper is the one I'd put on the wall. Safe triage is not the selection of the most likely diagnosis. It is a sequential decision under asymmetric cost, in which the single catastrophic miss outweighs many false alarms.

Corn: The single catastrophic miss outweighs many false alarms.

Herman: That's the whole design philosophy of these systems in one sentence. It's why the rules stay. It's why the human stays in the loop. It's why the dose calculator has a hard ceiling.

Corn: It's also why the big buttons exist. The interface is designed to disappear so the human can keep paying attention to the patient instead of the screen.

Herman: The interface is doing safety work. It's not cosmetic.

Corn: Okay. So where does that leave us?

Hilbert: The emojis weren't the vendor's idea.

Corn: ...What?

Hilbert: The little face icons. The condition indicators. Everybody assumes the software company put those in. They didn't.

Herman: How do you know that?

Hilbert: I was a night-shift registration clerk at a regional hospital for about a year. I wheeled the vitals cart between the triage bays and watched the nurses fight that exact screen. Same big buttons. Same color blocks. The system would time out mid-entry and lose the vitals a nurse had just typed in, and nobody could tell me why it did that.

Corn: That sounds infuriating.

Hilbert: It was. But the emojis. The nurses kept misreading the color codes under the fluorescent lights. Green and yellow looked the same in that hallway. So a local IT contractor went in and added the face icons on top. The vendor never officially supported them. If you called support and mentioned the emojis, they'd act like they didn't know what you were talking about.

Herman: A local contractor modified a hospital triage interface.

Hilbert: His name was Duane.

Corn: Duane.

Hilbert: Duane.

Corn: I need you to understand that I have approximately forty questions about Duane.

Hilbert: I shouldn't have said the name.

Herman: Is Duane still out there? Is half of American healthcare held together by one guy named Duane who keeps quietly patching interfaces nobody officially owns?

Hilbert: I don't know where Duane is.

Corn: Hilbert.

Hilbert: I have to go let somebody in. I'm the only one with the key.

Herman: Okay. So where does that leave us?

Corn: With a picture that's more interesting than the one we started with. The deployed reality is hybrid. Rules for the safety-critical logic, machine learning for risk scoring, language models as interfaces and feature extractors. The LLM accuracy numbers are climbing, but they're climbing toward a bar that isn't accuracy. It's the asymmetric cost problem. The single catastrophic miss outweighing many false alarms.

Herman: Which is the thing that keeps the human in the loop. And the tension is real. The UI is designed to disappear so the human stays engaged. But the better the backend gets, the more tempting it is to remove the human entirely. And Sivanathan's point is the brake on that. Until a system can reliably go looking for the red flag nobody asked about, you keep the person there.

Corn: The most sophisticated software in that urgent care room was the stuff Daniel couldn't see. And the big buttons were there to keep a human in the loop on purpose.

Herman: If you're enjoying the show, a review helps more than you'd think. It's how other people find us.

Corn: This has been My Weird Prompts. Our producer is Hilbert Flumingtop.

Herman: You can find everything at my weird prompts dot com. We'll be back soon.

Corn: See you tomorrow.