---
name: practice-math-program-model
description: Use this skill when a practice needs to decide whether a Medicare between-visit program (chronic care management, remote monitoring, APCM, transitional care, and the like) will pay for itself before it hires, buys, restarts, or switches, or wants to compare two programs or two payers. It runs the book's Practice Math: contribution margin per enrolled patient-month at low, base, and high scenarios with transparent, swappable inputs, break-even enrollment, a one-at-a-time sensitivity check for the three killers (participation, admin minutes, collection rate), payer-by-payer inputs, a patient-by-patient model for an APCM switch, and avoided work on its own line, then states start, restart, switch, or don't, with the reasoning. Triggers on requests like "will CCM pay for us," "model this program," "run Practice Math," "should we switch to APCM," "what's our break-even," "is RPM worth it," "which input matters most," "compare our Medicare Advantage plans for this program," or "what do I show the partners instead of gross collections."
---

# Practice Math Program Model
This skill is Labor as Code™ for the unit-economics method in *Getting
Paid to Do the Right Thing*. Labor as Code is a
skill that encapsulates a person's knowledge, judgment, taste, and skill
in durable, inspectable, versioned form. The know-how is pricing a
between-visit program the way it actually spends money, per enrolled
patient-month, with the Capture Ladder's losses built in, instead of
multiplying a fee-schedule amount by a hopeful number of patients.

The method lives in "A Program Survives Only if Each Patient-Month Covers Its Cost," which teaches
Practice Math and works it on Riverbend's choice between chronic care
management and advanced primary care management (Table 11.2 and the
APCM Practice Math box) and on Lakeshore's remote-monitoring rebuild
(Table 11.3). "Every Case Here Starts With the Wrong Diagnosis" adds
Hollis Street's APCM switch, the case for modeling a switch patient by
patient. "Test One Program for Ninety Days Before You Grow It" uses the model to pick the first program.
The worksheet is in the online companion's worksheets (intellectualfrontiers.com). Read them for the
argument and the worked numbers. This skill runs the same model on the
user's own inputs and never uses the book's illustrative rates as the
user's.

**The skill asks for every input.** Allowed amounts, rates, minutes,
labor cost, technology cost, attrition, fixed cost: each comes from the
user, their remittances, their time study, or their payer contracts. The
book's rates ($60 for CCM, $0.75 a minute, $6 of software, and the rest)
are round illustrations the author chose, and the book says so every
time. The skill never fills a cell with them. Where an input is
missing, the cell reads "unknown," and the skill names who can supply
it. The 2026 national amounts in the book's Table 11.1 are a reference
point for checking a user's number, never a substitute for it; fee
amounts change every year and vary by locality.

**The skill keeps care minutes fixed.** Care minutes are an input, and
cutting them would raise the margin. A program that makes money by
giving patients less of the work it exists to do has stopped being a
care program. The skill never varies them between scenarios and never
counts a care-minute cut as an improvement.

**This is not billing, coding, or legal advice.** Whether a code
applies, whether two services can be billed together for a patient, and
whether cost sharing can be reduced are questions for the practice's
billing lead and compliance adviser. The skill models what the user
tells it the rules are and marks each rule it relies on as "confirm
with billing or compliance."

## Before running

1. **Name the decision.** Start a program, restart one, keep or stop
   one, switch one (for example CCM to APCM), or choose between two.
   Name who decides: usually the partners.
2. **Name the payer.** Run traditional Medicare first. Each Medicare
   Advantage plan and each state Medicaid program gets its own column
   with its own inputs (Step 5).
3. **Ask for the inputs all at once.** Accept rough figures and record
   the source of each: remittances, Capture Ladder counts, a two-week
   time study, the fee schedule, a payer contract, or the user's
   estimate. If admin minutes come from an estimate rather than a
   study, say that the model's most important cost line is a guess.

## Step 1: Fill in the inputs

The model's inputs, as the book defines them:

- **Eligible patients:** patients who meet the program's clinical and
  payer rules. This sets the ceiling.
- **Participation rate:** enrolled ÷ eligible. Decides whether the
  program covers its fixed costs.
- **Served rate** (the worksheet calls it the service completion rate):
  served ÷ enrolled, the share that got the program's required work
  this month.
- **Allowed amount:** what the payer allows per served patient-month,
  including the patient's share, averaged across served patients and
  including any add-on code.
- **Patient cost sharing:** the patient's coinsurance, and the share of
  it the practice actually collects.
- **Billed rate:** billed ÷ served.
- **Collection rate:** paid ÷ billed.
- **Care minutes and admin minutes** per enrolled patient-month, split
  as the admin-minutes study splits them, times a loaded labor cost per
  minute.
- **Physician minutes:** care-plan sign-offs, escalations, and the
  monthly review, times a physician cost per minute. Keep them in; they
  are real minutes taken from something else.
- **Technology cost** per enrolled patient-month, and for monitoring
  programs the device, its replacement, and the ones that never come
  back.
- **Attrition:** the share of enrolled patients who leave each month,
  and the minutes it takes to replace one.
- **Fixed monthly cost** that doesn't scale with enrollment
  (supervision, the weekly huddle, reporting), for break-even.

Convert every rate to per enrolled patient-month. If the user gives care
minutes per served patient-month, say so and convert once, alongside.
The book's rule: model every program per enrolled patient-month, never
per paid claim. Dividing collections by paid claims hides every patient
the practice carried and didn't get paid for.

## Step 2: Compute three scenarios

Use the book's two lines of arithmetic, exactly:

```
revenue per enrolled patient-month =
  allowed amount × served rate × billed rate × collection rate
  × (0.8 + 0.2 × share of coinsurance collected)

contribution margin per enrolled patient-month =
  revenue
  − (care minutes + admin minutes) × labor cost per minute
  − physician minutes × physician cost per minute
  − technology
  − attrition × minutes to replace a patient × labor cost per minute
```

The factor in parentheses is traditional Medicare's split: Medicare
pays 80 percent of the allowed amount and the practice collects some
share of the patient's 20 percent. For another payer, ask what the
member owes and replace the factor with that payer's split; if the user
doesn't know, mark it "not stated; ask."

Build three columns:

- **Low:** the program goes badly. Use the user's pessimistic value for
  every input, and put a denial reserve in the collection rate even if
  the collection history is good.
- **Base:** the user's best estimate of what a competent operation
  produces in its first year.
- **High:** the user's optimistic values.

Where the program is running today, add a **Today** column from actual
numbers. Show every line of the calculation in a table, per enrolled
patient-month, so the user can recalculate one case by hand.

Then apply the book's test to the base case. Reject it as a base case
if it needs perfect enrollment, perfect collection, or cheap labor, or
if it assumes a served rate above anything the practice's own ladder
has shown without a reason the user can name. If the program works only
in the high column, it doesn't work.

## Step 3: Compute break-even

```
break-even enrolled patients = fixed monthly cost ÷ contribution margin per enrolled patient-month
```

Compute it for each scenario and express it as a share of eligible
patients. Compare it with the current enrollment. A scenario with a
negative margin never breaks even at any size: growth multiplies the
loss. Say that plainly whenever the low case, or today's program, is
negative.

## Step 4: Find the input that matters most

Run a one-at-a-time sensitivity check. For each input except care
minutes, set it to its low value and then its high value, hold
everything else at base, and record the margin both times. Rank inputs
by the size of the swing. The ranking must follow the numbers, not the
loudest explanation.

Name the three killers the book identifies when they show up:

- **Participation,** which works twice: the share of eligible patients
  who enroll decides whether the program reaches break-even, and the
  served rate decides how much of each enrolled patient-month becomes
  revenue. Both are operations problems of capacity and queue design.
- **Admin minutes.** The payment is fixed; the admin minutes are the
  practice's. If they haven't been measured, point to the
  `administrative-denominator-reduction` skill.
- **Collection rate.** It can look harmless when the ranges are narrow.
  Collection doesn't drift; it falls off a cliff when a payer changes a
  rule, a consent form goes missing across a cohort, or a vendor's notes
  stop supporting claims. Recompute the base case at a sharply lower
  collection rate the user names, and show what's left.

For the top three inputs, name the single operational change most
likely to move each toward its high value and how the practice would
measure whether it did. Reject any change that raises the margin by
cutting care minutes, enrolling patients who don't need the program, or
billing for work that didn't happen.

## Step 5: Run each payer separately

For each Medicare Advantage plan or Medicaid program, the method stays
the same and the inputs change. Ask the questions from the book's Table
11.4 and mark each unanswered cell "not stated; ask":

| Input | Ask each MA plan and the state Medicaid program |
| --- | --- |
| Allowed amount | Do you pay for this code, and at what rate? Is it tied to Medicare's rate? |
| Patient cost sharing | What does the member owe, if anything? Is it waived for this service? |
| Billed and collection rates | Do you require prior authorization, a referral, or documentation beyond Medicare's? |
| Served rate and care minutes | Do you already run care management for this member, so our calls would duplicate yours? |
| Physician and admin minutes | Will you share the data we need, such as discharge notices, in a form we can use? |
| Upside outside the fee schedule | Do you pay anything for quality or avoided admissions in our contract? |

When the user pastes contract or manual excerpts, extract only what the
text states. A general-purpose AI fills gaps with what's typical, and
typical isn't the practice's contract. Flag any plan that runs its own
care-management program for the same members; duplicate calls annoy
patients and the plan may not pay the practice at all.

## Step 6: Model a switch patient by patient

For a switch between programs (the book's case is CCM plus transitional
care management to APCM), model the panel as it actually is, not as an
average:

1. Group the patients the switch would touch by how they bill today
   (for example, base code only, base code plus add-on, event services
   like transitional care) and by the level or tier they would bill
   under after the switch.
2. Compute monthly revenue before and after for each group from the
   user's rates, and the change in admin minutes (for APCM, the
   counting that goes away).
3. Include what the switch gives up and what it adds, as the user's
   billing lead confirms them. For APCM the book names three: payment
   depends on the patient's level, and a large share of a primary care
   panel may sit in the lowest level; billing it attests that a set of
   capabilities exists; and it can't be billed with individual CCM,
   PCM, or transitional care management for the same patient in the
   same month. Price the added fixed cost of the capabilities. If the
   practice's components live in one person's head, flag that billing
   would attest to capabilities it doesn't reliably have.
4. Compute break-even enrollment for the new program with its own fixed
   cost.

A small panel with a concentrated group of heavy users and frequent
discharges can lose money on a switch that suits a larger panel. The
book's rule: model the switch patient by patient before you move the
whole panel.

If lowest-level patients would owe a monthly coinsurance for a program
they may never notice using, say so; the consent conversation has to
name it, and the patient has to be able to see what the program gives
them.

## Step 7: Keep cost sharing and avoided work honest

- **Cost sharing.** The model carries one input, the share of
  coinsurance collected. Say that its larger effect is on participation,
  at the Offered → Enrolled rung, and that the evidence on how much
  cost sharing holds down enrollment is qualitative; the user measures
  it on their own ladder. Routinely waiving the patient's share is a
  compliance question with serious consequences. The skill never models
  a waiver as a choice the practice makes on its own; it marks it
  "compliance adviser to decide."
- **Avoided work.** Unplanned calls that don't happen, emergency visits
  that don't happen: real, hard to measure, easy to exaggerate. Put
  avoided work on its own line, measured the way admin minutes are
  measured, and keep it out of the margin. Never use it to rescue a
  program whose margin is negative.

## Step 8: Conclude with a decision and its reasoning

State one of these, citing the specific rows:

- **Start (or restart) with a crawl.** The base case is positive at
  realistic participation, collection, and labor cost, and break-even
  sits at a size the practice can reach. Name the inputs the weekly
  huddle should watch first (the top of the sensitivity ranking) and
  hand the model to the `crawl-walk-run-launch-plan` skill for days
  11–20.
- **Fix first, then start.** The base case goes negative only because
  of an input the practice controls, usually admin minutes or the
  served rate. Name the input, the target value that turns the base
  case positive, and the measurement that would show it.
- **Don't start, or stop.** The base case fails the book's test, or
  today's program loses money and no realistic change in the inputs the
  practice controls fixes it. Say what would reverse the decision.
- **Don't switch yet.** Write, in one paragraph, the conditions under
  which the switch would win (for example, a lower share of heavy-use
  patients, fewer billable transitions, or enrollment reliably above the
  new program's break-even), and the date to rerun the model, such as
  when next year's fee schedule comes out.

Where the book's own material presents two defensible paths, present
them side by side. The common case is two
programs whose margins rank differently at different sizes: one breaks
even at a size the practice already has and teaches the operation the
other needs; the other has a better margin per patient but a higher
fixed cost and a larger break-even. Give each option its numbers, what
makes it the right call, and the enrollment or input level at which the
answer flips. Riverbend's rule is the shape to follow: move to the
larger program "when we can reliably enroll and serve" its break-even
number of patients, "and not before."

Where an unknown cell could change the sign of the base-case margin,
say so, and make the recommendation conditional on filling it: the
two-week time study, three months of remittances, or a plan's written
answer. Where too many inputs are unknown for any case to mean
anything, say that, list the missing inputs, and name who supplies each.

For the partners, the model replaces the revenue slide. Report
contribution margin per enrolled patient-month, next to the served rate
and admin minutes, never gross collections alone. A revenue line with no
cost line beside it can make the worst program in the practice look
like the best one.

## Checks before calling the work done

- **Every input traces to the user,** with its source recorded. Delete
  any rate the skill supplied.
- **Everything is per enrolled patient-month.** Any per-served or
  per-paid figure is labeled and converted once.
- **Care minutes are identical in every column.**
- **One case recalculates by hand** to the same margin.
- **Break-even is shown for every scenario,** and negative scenarios say
  "never."
- **Each payer has its own column,** or the conclusion says the model
  covers traditional Medicare only.
- **Avoided work sits outside the margin.**
- **The conclusion is start, fix first, don't start or stop, don't
  switch yet, or labeled options,** with reasoning.

## What this skill does not do

It doesn't supply fee amounts, labor costs, or rates, and it doesn't
borrow the book's illustrative numbers as defaults. It doesn't decide
whether a code applies, whether services can be billed together, or
whether cost sharing can be waived. It doesn't count avoided work or
downstream savings as program revenue. It doesn't make the decision; the
partners do, with the three columns in front of them. A three-case model
is a hypothesis about the practice. It says which program to start with
and which inputs to watch; only a small, watched crawl says which column
the practice is actually in.