The Best Medical Coders Don’t Memorize Rules. They Think Like Philosophers

The Best Medical Coders Don’t Memorize Rules. They Think Like Philosophers

Here’s a belief worth rethinking: that medical coding is a rules problem. That if you study the guidelines hard enough, the right code falls out.

It doesn’t. The hardest part of the job is the part the rules can’t reach. And the training that prepares you for it isn’t in any coding manual. It’s philosophy. That sounds like a stretch. It isn’t. And it pays off right away.

Start 2,400 years ago. Aristotle set out to map the most basic categories of existence, the fundamental ways reality divides. He landed on ten. What he never managed was to explain why those ten and not some other set. Centuries later, Kant put his finger on the problem: Aristotle had no organizing principle. He simply gathered the categories up as he stumbled on them. The list was useful. The foundation under it was never there.

Now look at the classification you use every day. It has the same hole.

ICD-10-CM is not a logically consistent system, and that’s well documented. Different chapters sort by different things. Some by cause. Some by body site. Some by how a condition shows up. Some by age. There’s no single principle running through all of it. It’s Aristotle’s problem wearing a lab coat: a set of categories with no principled reason for being these categories. Conflicts between those sorting axes are a known source of coding defects.

The structure even breaks its own rules. When the alphanumeric space runs out, codes get parked in sections where they don’t belong. And the hierarchy isn’t really a hierarchy. In a true parent-child structure, everything true of the parent is true of the child. ICD-10-CM doesn’t work that way. The relationship between a category and what sits under it is membership, not inheritance. So you can’t reason cleanly from the general to the specific. You feel it every time the broad category refuses to tell you which specific code to pick.

The guidelines inherit the same trouble, one level up.

Take Excludes1. It says two conditions are mutually exclusive and can’t be coded together. Then comes the exception: if the two are unrelated, you can code both. But “unrelated” is never defined. And when the relationship isn’t clear, the instruction is to query the provider. It looks like a clean logical rule. Underneath, it’s a judgment call, handed to a human at exactly the moment a logical system would have to produce a definite answer.

The definition of the principal diagnosis pulls the same move. “The condition established after study to be chiefly responsible for occasioning the admission.” Sounds like a rule. Read it again and it’s a standard, the kind that needs interpretation on nearly every complicated case. The guidelines admit it. There’s a whole section for when two conditions meet the definition equally well, and it says you may sequence either one first. Logic can’t settle that. The section just gives you permission to make the call the guidelines can’t make for you.

And here’s the part people miss: the guidelines rank below the classification itself. The conventions in the Tabular List and Alphabetic Index take precedence over the guidelines. So the guidelines sit on top of a system that isn’t logically consistent, and they absorb its contradictions.

None of this is bad design. It’s what happens when you force sharp categories onto messy, continuous reality. Aristotle hit that wall. Every classification system since has hit it too. The wall isn’t going anywhere. The only variable is whether you can see it.

This is why philosophy turns out to be so practical here. Not because it hands you answers. Because it builds the one skill the job quietly depends on: the ability to hold a problem open without forcing it shut.

The best coders already do this. They sit with ambiguity instead of collapsing it into a tidy answer the evidence won’t support. We usually call that intuition. It’s not intuition. It’s a trainable skill, and philosophy trains it more directly than anything else.

Start with formal logic. It teaches you to tell a valid argument from a sound one, a rule that truly applies from one that only looks like it does, a conclusion that follows from one that merely feels like it follows. Three different things. Philosophy makes each one visible before it becomes a mistake.

Informal logic gets even more useful, because it studies how smart people reason badly. Not from broken logic, but from a premise they assumed instead of checked. Confirmation bias tips the scale toward the conclusion you already hold. The availability heuristic makes the most recent, vivid case feel typical. Studying these won’t make you immune. It will help you catch yourself faster, which is most of the battle.

Then there’s the move Socrates built his whole method on. He asked questions until a belief revealed the precise point where it ran out of support. Follow any claim far enough and it either holds or it cracks. The ones that hold get sturdier for the test. It’s a skill you can learn, and it makes you harder to fool, including by yourself.

All of that builds intellectual humility. The recognition that your best current answer might be wrong, that confidence is not evidence, that the most dangerous errors are the ones that feel the most certain. Socrates said the only thing he knew was that he knew nothing. He meant it as a method, not as modesty. Uncertainty you hold on purpose is a tool. Uncertainty you pretend away is a liability.

Here’s my favorite example, because it names something every auditor has felt but rarely has a word for. In 1963, a philosopher named Edmund Gettier published a paper just three pages long. He showed that a belief can be justified, true, and still not count as knowledge, because the justification and the truth got connected by luck rather than by the reasoning that’s supposed to link them.

Picture the audit version. The documentation supports the code. The code turns out to be right. But the support and the rightness aren’t connected. Maybe the note was wrong in a way that happened to cancel out. Maybe the correct answer arrived for a reason that has nothing to do with how anyone got there. Justified. True. Not knowledge. Right by luck. That situation is everywhere in this work, and most quality processes can’t see it, because they check whether a code is defensible and whether it’s correct, and never whether those two things are joined. Philosophy gives that gap a name. And once something has a name, you can finally start to catch it.

Wittgenstein noticed something about how everyday concepts actually work. Most of them don’t have a single feature that every example shares. They’re held together by overlapping resemblances, the way a family is. His example was the word “game.” There’s no one thing every game has in common. There’s just a web of loose similarities.

The conditions that generate the most coding disputes work exactly like that. No crisp definition that fits every case. They show up a little differently in every record.

And there’s a deeper problem hiding inside that one. These conditions don’t just lack a single defining feature. They sit on a continuum, with no clean point where one thing turns into another. Philosophers have a name for this too. They call it vagueness, and they have a famous puzzle that exposes it: the paradox of the heap. One grain of wheat isn’t a heap. Adding a single grain never turns a non-heap into a heap. Yet pile up enough grains and you plainly have one. So where’s the line? There isn’t one. Clear cases at both ends, and no precise moment where it flips.

Every disputed condition is built like that heap. Try to name the exact grain where mild becomes moderate, where a finding becomes a diagnosis, where deconditioning becomes a named disease. There is no such grain. The extremes are obvious. The boundary is invented. And the classification has to draw it anyway. Drawing it doesn’t erase the messiness. It just relocates it. The ambiguity that lived in the concept becomes ambiguity in the code, then in the dispute, then in the audit.

Sepsis is the clearest proof that the line gets invented rather than discovered. The field has drawn it in at least three different places. In 1991, Sepsis-1 set the boundary at infection plus a systemic inflammatory response: temperature, heart rate, respiratory rate, white blood cell count. Sepsis-2 kept that frame and widened the criteria. Then in 2016, Sepsis-3 moved the line somewhere else entirely: infection plus organ dysfunction, measured as a jump of two or more points on the SOFA score, with the old inflammatory signs set aside as too unspecific to mean much. Same word. Three thresholds. And it’s still not settled. The teams who screen and treat patients are often told to keep using inflammatory signs the current definition no longer counts, and a single chart can pass one definition while failing the next.

Now watch what the coder is allowed to do about it. Almost nothing. ICD-10-CM doesn’t let you choose by clinical definition, because code assignment isn’t based on clinical criteria at all. It’s based on what the provider writes. The official guideline says so directly: the provider’s statement that the condition exists is enough, and the code does not depend on the criteria the provider used to reach it. Provider writes sepsis, the code is sepsis, whether or not a SOFA score ever budged.

So the boundary problem never lands on the coder. It slides one seat over, into clinical validation, and that’s where the real fight happens. A payer denies the claim on Sepsis-3 organ dysfunction, against a record documented to Sepsis-2. And the official position names that disagreement precisely: if the provider documents sepsis and the coder codes it, and a validation reviewer later disagrees, that’s a clinical issue, not a coding error. Same chart. Same patient. Nobody misread anything. The entire argument is about whether the documented word should stand, measured against a threshold the field has moved three times and still argues about.

That’s the tell. The rule that says code the word, not the criteria, is the system quietly admitting it can’t draw the line, so it passes the call along. First to the provider’s pen. Then to the validator’s judgment. The vagueness never resolves at any step. It just gets handed to whoever has to decide next. A lot of the time, that’s you.

Three decades of expert consensus couldn’t pin that line down, for the same reason Aristotle couldn’t ground his ten categories and the heap has no first grain. There’s no line in the territory. There’s only the one the system makes you draw.

Philosophy won’t make that disappear. What it does is change how you make the call.

Without that understanding, you keep asking the one question the situation can’t answer. Is this really the condition? Where exactly is the line? And when no answer comes, you read it as your own failure. So you do one of two things. You force a confidence the evidence won’t support, or you freeze and wait for a rule that’s never going to arrive. Both are how good reviewers go wrong, and neither is a knowledge problem. It’s the wrong question, asked with too much faith that it has an answer.

With that understanding, you ask a better question. Not where the line is, because there is no line, but what the disagreement is really about and what your decision can rest on. You stop trying to be right about an invented boundary and start making a judgment you can stand behind: whether the reasoning holds together, whether it’s supported, whether it survives someone pushing on it. The decision doesn’t get easier. It gets placed on ground that exists.

Aristotle had a word for that kind of judgment. He called it phronesis, practical wisdom. It isn’t running the rules faster. It’s knowing which question a situation can answer and refusing the one it can’t. Seeing when the rules are underdetermined, when two principles collide, when the case in front of you doesn’t fit the frame at all. Philosophy trains for exactly that. Not for answers. For better questions, asked before you commit.

The field gives you the rules. Then, again and again, the rules hand the hard call back to you. Query the provider. Sequence either one. Decide whether the documented word holds up. Philosophy is what lets you make those calls well, not by telling you where the line is, but by showing you there isn’t one and putting the weight back where it belongs: on a judgment you can defend.

That judgment isn’t the soft part of the job. In a system that’s vague at the core and inconsistent at the seams, it’s the whole job. And it’s the part no rulebook will ever do for you.