AI Denial Management for Medical Billing: Group, Appeal, Track

Export a month of remittances, keep only the claim reference, reason code, payer, procedure and amount, then group the denied lines by reason code and total each group in dollars. Ask AI to draft one appeal template per fixable group and to rank groups by recoverable value. A person checks every letter against the chart.

The order matters more than the tool. Most teams open a chat window and paste in one denial at a time, which produces a pile of polite letters and no idea why claims keep bouncing. Grouping first shows you that four or five causes explain most of the money, and that some of them need a corrected claim, not an appeal at all.

Follow me on Instagram@sagnikteaches

Why grouping beats chasing denials one at a time

A denial is a symptom. The cause sits upstream: a missing authorisation, a modifier left off, a patient whose cover ended last month. If you appeal each denial separately you treat the symptom 400 times. If you group them, you see that 58 of the 412 denied lines this month share one reason code, and you fix the front desk step that caused them.

Connect on LinkedInSagnik Bhattacharya

Grouping also tells you the right response. Some denials are not appealable at all. A contractual adjustment (reason code 45) simply means the payer's fee schedule is lower than your charge, and there is nothing to dispute. Others need a corrected claim, others need a records attachment, and only a minority need a real written appeal arguing the clinical case. AI is useful at three points: sorting the export, drafting the paperwork for each response type and spotting patterns across months. It is not useful for deciding whether a service was medically necessary.

Subscribe on YouTube@sagnikteaches

If you are still choosing tools for the wider billing job, the tool-by-job comparison for medical billing covers scrubbing, coding and denials side by side.

Export the remits and strip what the AI does not need

Your billing system or clearinghouse can export the electronic remittance (the 835 file) or a spreadsheet version of it. Pull the last full month, or the last 90 days if volume is low. Keep these columns and delete everything else:

• An internal claim or line reference (your own number, not the payer's member ID).
• Payer name and plan type.
• Date of service and date of the remit.
• Procedure code and modifier.
• Rendering clinician (initials are enough).
• Billed amount, allowed amount, paid amount and the denied amount.
• Group code (CO, PR, OA or PI) and the reason code, plus any remark code.

Delete patient name, date of birth, member ID, address and phone number. The grouping step does not need any of them, and the less identifying data in the file the easier it is to stay inside your own privacy rules. If you later need the patient for an appeal, look the claim up in your system by its reference. Before any file goes near an AI tool, check what your agreement and settings allow: business plans of the major assistants do not train on your content by default, but that is a setting and a contract question for you to confirm, not an assumption. If your rules say patient data may not go into a general assistant at all, do the grouping with a pivot table and use AI only to draft the wording from anonymised examples.

Check the file before you trust it

Count the rows and add the denied amounts in the spreadsheet itself, then compare the totals to your clearinghouse report. If they differ, a column has shifted or the export dropped a page. Do this once, note the two totals on the tracking sheet, and you will catch a bad export in thirty seconds instead of after an afternoon of drafting.

Group by reason code, then by what you must do next

The reason code (the CARC, or claim adjustment reason code, maintained in X12's published code list) tells you why the line was adjusted. The group code tells you who carries the cost: CO is a contractual obligation, normally an amount the practice absorbs rather than bills to the patient (check your contract), PR is patient responsibility such as deductible or coinsurance, OA is other adjustments and PI is payer-initiated reductions. Denials worth working are mostly CO lines.

These are the reason codes that fill most practices' denial lists, with the response each normally calls for. Always read the remark code too, because it often names the exact missing item.

Payers add their own remark codes and sometimes interpret a reason code more narrowly than the list suggests, so treat the table as a starting point and confirm against each payer's provider manual. Add a column called response type with four values: Fix and resubmit, Send records, Written appeal, No action. That column is what turns the export into a work queue.

Let AI do the first sort, then verify it

If you have a few hundred lines, a pivot table does the grouping in a minute. AI earns its place on the messy part: free-text remark descriptions, payer-specific codes and lines where the same cause appears under different codes. Here is a prompt for the sort.

You are helping a medical billing team triage denied claim lines.
I will paste a table with these columns: line_ref, payer, dos, cpt, modifier,
group_code, reason_code, remark_code, denied_amount. There is no patient data.

1. Assign each line a response type: Fix and resubmit, Send records,
   Written appeal, or No action. Base this only on the reason and remark
   codes. If a line is ambiguous, label it "Check" and say why in one line.
2. Group the lines by reason code. For each group give: line count, total
   denied amount, and the response type.
3. Do NOT invent code meanings. If you are unsure what a remark code means,
   say so.
4. Output a table, then a list of any lines you could not classify.

An illustrative reply starts like this: "Reason 16, 96 lines, $11,520, Fix and resubmit; remark codes suggest missing referring provider on 61 of them. Reason 197, 58 lines, $17,400, Written appeal or retro-authorisation. Three lines labelled Check: remark code not recognised." Spot-check ten lines yourself against the source file. If more than one in ten is wrong, tighten the prompt or go back to the pivot table, and keep AI for the letters.

A worked month: 412 denied lines, $61,500

Here is an illustrative month for an outpatient practice with six clinicians. All figures are invented to show the method, and your overturn rates will differ. The export has 412 denied lines worth $61,500, grouped like this:

The success rates in that table are the practice's own from earlier months, taken from the tracking sheet described below. If you have no history yet, leave the column blank for the first month and fill it as outcomes arrive; do not borrow a figure from a vendor brochure.

Now the time sum. Corrected claims take about six minutes each once the fix is known, so 96 lines is roughly ten hours. The 47 medical-necessity lines need a written appeal at, say, 35 minutes each when written from scratch, which is about 27 hours. With an AI first draft that a biller then checks against the chart, suppose it drops to about 15 minutes, which is just under 12 hours. Those are assumptions to time on your own first batch, not promises. What the grouping does show is where the hours are best spent: the 96 billing-error lines recover $9,792 for ten hours, around $980 an hour, while the 71 bundled lines recover about $1,700 for a similar effort.

The bigger finding is upstream. 96 lines with reason code 16 and 58 with 197 are two front-end problems: 154 lines, $28,920 denied, caused by missing referring provider details and authorisations not logged before treatment. Fixing those two steps beats any amount of appeal drafting. The related tutorial on tracking prior authorisations with AI covers the second one.

Draft the appeal from a template, not from a blank page

For each group that needs a written appeal, build one template and let AI fill the variable parts from the chart facts that a person supplies. A template keeps the structure the payer's reviewer expects: who you are, what was denied, why you disagree, what is attached and what you are asking for. A blank-page request tends to produce confident prose with arguments nobody checked.

The appeal template for a medical-necessity denial

[Practice name] | [Payer appeals department] | [Date]
Re: Appeal of claim [claim reference], date of service [date]
Procedure [code], denied under reason code [50] / remark [code]

Dear Appeals Reviewer,

We are appealing the denial of the service above on the ground that it was
medically necessary. Summary of the case:

- Presenting problem and relevant history: [clinician-supplied, 2-3 lines]
- Why this service was indicated: [clinician-supplied reasoning]
- Prior treatment tried and the response: [dates, outcome]
- Documentation attached: [list: visit note dates, referral, test results]
- Payer policy relied on: [policy name and number from the payer's own manual]

We ask that the denial be overturned and the claim reprocessed at the
contracted rate. Please contact [name, role, phone] for further information.

[Name, role, credentials]

The person who knows the case fills the bracketed clinical lines. AI turns rough notes into tidy paragraphs and checks that every attachment mentioned in the letter is on the list. The prompt:

Below is an appeal template and the facts a clinician supplied. Fill the
template using ONLY these facts. Do not add any clinical claim, guideline,
study or policy number that is not in the facts. Where something is missing,
leave a bracket and list the missing items at the end. Keep the tone
factual and under 300 words.

Before and after: a rough note turned into an appeal paragraph

Illustrative input from a clinician: "pt had 8 wks of PT with little change, still can't lift above shoulder, imaging 3/14 shows partial tear, surgeon referral 3/20, so more sessions needed." The draft that comes back, after the ID details are removed, reads along these lines: "The patient completed eight weeks of conservative therapy with limited improvement and remains unable to lift the arm above shoulder height. Imaging dated 14 March showed a partial tear and the patient was referred to a surgeon on 20 March. Additional sessions were requested to maintain function while the surgical opinion was obtained." Your fix: confirm each date against the chart, delete "limited improvement" if the notes record a measured score, and add the score. The AI made it readable; the clinician made it true.

The mistake that gets appeals rejected: invented support

A realistic failure: a drafted letter cites "the payer's clinical policy CP-2231 on conservative management" and nobody checks. The policy number was made up by the model, the reviewer cannot find it and the letter looks careless. The rule is simple. Any policy, guideline or code reference in a letter must come from the payer's own manual or the chart, pasted in by a person. Add a line to your prompt saying exactly that, and have the checker search each reference in the manual before sending.

The second common failure is overreach. AI will happily write "the service was clearly medically necessary" when the chart says only that the patient had pain. Strong words are the clinician's to use, not the draft's. A third is dropping the deadline: a beautiful letter sent after the appeal window closes recovers nothing, so the due date goes on the tracking sheet the day the remit is read.

Handle the other response types without an appeal letter

Fix and resubmit (reason codes 4 and 16)

These need a corrected claim, so a letter is wasted effort. AI helps by reading the remark code and listing the likely missing field. Ask it: "For each line, state the most probable correction in one sentence, based on the remark code text only." The biller makes the correction in the billing system and resubmits. Then add the cause to a front-end checklist, for example "referring provider present before claim release".

Send records (reason code 252)

The payer wants documentation, so a short cover note with the attachments is enough. Template: "Claim [ref], date of service [date]. You requested additional documentation under remark code [code]. Attached: [list]. Please reprocess." AI drafts nothing here that your system cannot already do, so skip it unless you have a high volume.

Wrong payer (reason codes 22 and 109)

Re-verify cover, find the correct payer and rebill. A good use of AI is a script for the front desk to ask about other insurance at booking. Ask it to write a two-sentence question and a three-field capture form.

Filing limit (reason code 29)

The only useful response is proof that you filed on time: a clearinghouse acceptance report with a date. Pull that report, attach it and cite the date. If you cannot produce one, write the line off and record the cause. A short appeal drafted by AI from the dates you give it is fine, as long as the dates come from the clearinghouse report and not the model.

Track every denial on one sheet

Without a tracking sheet you will re-do work and lose deadlines. A single spreadsheet with one row per denied line, or per claim if that is how you work, is enough. Columns:

• Line reference, payer, date of service, procedure, denied amount.
• Reason code, remark code, response type.
• Date remit received, appeal or corrected-claim deadline (from the contract), date sent, method sent.
• Owner (who is working it) and status: To do, Sent, Awaiting reply, Overturned, Upheld, Written off.
• Amount recovered, date recovered, root cause (one of your front-end checks, for example "auth not logged").
• Next action and next action date.

Sort by deadline each Monday. Add a conditional-format rule that turns the row amber at 14 days before the deadline and red at 5 days. If you want AI to help, paste an anonymised view of the sheet and ask: "List the rows whose deadline is within 14 days and are not yet Sent, oldest deadline first." It is a sorting job a filter also does, so use whichever is faster, but AI is handy for the Friday summary: "Write five lines for the practice manager: what was recovered, what is outstanding by payer, which root causes recurred."

The same sheet feeds a monthly view. Two numbers matter: the denial rate (denied lines divided by lines submitted; in the example 412 of 3,860 is about 10.7 per cent) and recovered dollars divided by denied dollars. Track the denial rate by payer and by root cause for three months before deciding what to change. The monthly practice dashboard is a natural home for both.

Find the repeat offenders with a payer-by-code table

After two or three months you have enough rows to ask which payer and code combinations keep coming back. Build a pivot of payer against reason code with counts and dollars, then ask AI for a short list of hypotheses for the top three cells. Illustrative output: "Payer B, reason 197, 31 lines: authorisation may be required for sessions beyond the first six; check the payer's manual for a visit threshold." You test the hypothesis against the payer's published rules and your own authorisation log. If it holds, that goes on the front-desk checklist: "payer B, from session 7, authorisation number in the record before booking".

This is where AI is genuinely good: reading a table, proposing causes and suggesting what to check. It is also where it can overreach, so each hypothesis stays a hypothesis until a person confirms it from the payer's own documents.

What stays with a person

Three jobs do not go to AI. A person decides whether an appeal is worth sending, because that needs the contract and the chart. A person signs the letter, because it is a statement made by the practice. And a person decides when to stop: if a payer has upheld a denial twice, the next step is a call to the provider relations team or a contract conversation, not a third letter. A written rule such as "two upheld appeals, then escalate to the practice manager" saves hours. For a light sign-off step that works for every AI-drafted document, see setting up human review without slowing down.

Also keep the denied dollars separate from patient balances. A PR line (deductible, coinsurance) is billed to the patient according to your own policy, and AI can help word a statement, but that belongs to a different workflow. The tutorial on working aged claims with AI covers the follow-up cycle for claims that are neither paid nor denied.

A first-month plan you can run in a week

1. Day 1: export last month's remits, remove patient identifiers, reconcile the totals against the clearinghouse report.
2. Day 2: group by reason code in a pivot table, add the response-type column, use the triage prompt on the unclear lines and spot-check ten.
3. Day 3: pick the two groups with the highest expected recovery. Build the tracking sheet and enter every line with its deadline.
4. Day 4: build one template for the written-appeal group and test it on three real denials with a clinician filling the facts.
5. Day 5: send the first corrected claims and appeals. Write down the two front-end checks that would have prevented the two biggest groups.
6. Month end: record outcomes, update your own success rates and re-run the grouping on the new month.

Time how long each step actually takes and keep the numbers. After a month you will know your real hours per appeal with and without a draft, which is the only figure that tells you whether this is worth continuing. If the numbers are poor, the likely culprits are an unclean export, a template that is too long or clinicians who have no time to supply the case facts, and each is cheaper to fix than to ignore.

If you would rather map this against your own billing system with someone who has done it before, that is what my AI implementation consultation covers; you can get in touch here.

Denial-management questions billing teams ask

Can I paste a remittance file straight into ChatGPT or Claude?

Not as exported. A remit carries patient names, member IDs and dates of birth. Strip those columns first, keep the claim reference, reason code and amounts, and only use a business plan or agreement your own privacy rules allow. If you cannot confirm that, do the grouping in a spreadsheet and use AI only for wording.

Should AI decide which denials are worth appealing?

It can rank them using the numbers you give it, such as amount, reason code and your past overturn rate. The final call stays with a person who knows the payer contract and has read the chart. Treat the ranking as a sorted to-do list, never as a verdict.

How many denials are enough to bother grouping?

Once a month produces more than about 50 denied lines, grouping pays for itself, because the same three or four reasons usually account for most of them. Below that, a simple list sorted by reason code and amount is enough, and AI is optional.

What if the payer's appeal deadline has already passed?

Check the contract and the payer's provider manual for corrected-claim and appeal windows, which vary. If the window has closed, note it on the tracking sheet as written off for timeliness and feed that into your front-end checks, so the same cause does not recur.

Further reads

• Physical Therapy Billing: AI Checks for Claims and Time Entries — Pre-submission checks that stop denials before they happen.
• ChatGPT for Clinicians: Does the Individual BAA Cover Your Practice? — What a business associate agreement does and does not cover.
• AI for Dental Billing: Claim Checks, Statements and Follow-Up — The same grouping approach applied to dental claims.
• Can AI Do Medical Billing and Coding? What Still Needs a Human — Where a human must check AI coding suggestions.
• Using AI for Medical Billing: Spot Missed Charges From Visit Notes — Find revenue that never reached a claim at all.
• Outsourced Medical Billing or In-House AI Tools? A Decision Rule — Whether to keep denials in-house or outsource them.
• AI Claim Scrubber: What It Catches and What It Misses — Modifier, bundling and diagnosis edits are caught; eligibility, documentation and fresh payer rules often are not. Test one on 50 claims.
• Best AI Scribe for Urgent Care: Fast-Visit Notes and Coding Checks — How to pick an AI scribe for walk-in clinics: five-minute visits, templates per complaint, coding suggestions and a one-week test.
• ChatGPT for Medical Billing: Appeals and Claim Checks Without PHI — A redaction method, appeal and claim-check prompts, and the review step that lets a billing team use ChatGPT without pasting patient data.
• Medical Billing Client Onboarding: Contracts, Access, AI Reports — A medical billing company's onboarding sequence for a new practice, from contract and BAA to access, enrolment checks and the first report.
• Medical Billing Proposal: Draft Practice Quotes With AI — Draft a medical billing proposal with AI: percentage vs flat-fee pricing, a scope table, an onboarding timeline and a fully worked quote.
• Medical Practice Credentialing: Track Payer Renewals With AI — Build a payer credentialing and renewal tracker with AI: columns, expiry alerts, a document checklist and questions to ask about delegated credentialing.
• Medicare Codes for Billing Psychology in Australia: AI Claim Checks — A pre-submission claim check for Australian psychologists: match MBS item numbers to times, referrals and session counts, flag mismatches and never upcode.
• AI for Medical Billing Companies: Seven Jobs to Automate First — Seven jobs for a medical billing company to automate first, ranked by risk, with sample prompts, a worked denial-letter example and the human checks each needs.
• AI Tools and AI Development: The Complete 2026 Guide — the AI hub, including every tutorial in the AI-for-business series.

Sources: X12 Claim Adjustment Reason Code list (x12.org), payer provider manuals and contracts (check your own), vendor privacy and data-control pages.