Should you switch to an HSA plan? Let your own medical bills answer

Sat, 14 Nov 2026 00:00:00 +0000

Every fall I face the same open-enrollment question. My employer offers the usual PPO and a couple of high-deductible plans that come with a health savings account (HSA). The HSA plans have much lower premiums, and the employer puts money into the account, but the deductible is several thousand dollars. So which one costs less?

The comparison charts in the benefits guide don’t answer that. They compare a “typical” employee who visits the doctor twice and fills a generic prescription. I’m not that person, and you probably aren’t either.

⚠️ Warning: experimental alpha software. This tool is new, has had limited testing, and may have bugs that produce wrong numbers. Treat its results as a starting point for your own research, not as an answer. Before you change plans, check the recommendation against your benefits guide and your insurer’s plan documents.

Why I built this

What you actually pay depends on details the charts skip: when in the year your bills land, what your insurer negotiated for each visit, which services get a flat copay and which go toward the deductible, and whether your family hits the out-of-pocket maximum. You already have that information. It’s in your insurer’s claims history and in years of Explanation of Benefits (EOB) statements.

I wanted to use real claims, but going through years of them by hand was tedious and easy to get wrong. I also didn’t want to upload raw medical records to a chatbot to do it for me. So I split the work in two. A small set of tools runs on my own computer, reads the claims and strips out personal details. Then an AI assistant “skill” walks anyone through the process. The assistant runs on a cloud AI model, but it works from the de-identified totals the local tools produce rather than from the original records.

What it does

You give it your claims history and a description of each plan you can choose. It then:

Removes personal details (names, member IDs, doctors, drug names, exact dates) and keeps only the dollar amounts, the month and a broad category.
Replays every claim, in order, under each plan’s rules: copays, deductible, coinsurance, family limits and the out-of-pocket maximum.
Adds the things people often forget: premiums, the money your employer puts in the HSA, and the taxes you save by contributing to it.
Checks itself by replaying your current plan and comparing the result with what you actually paid. If the two don’t line up, it tells you before showing any recommendation.

The result is an Excel workbook with your net yearly cost under each plan, plus a few “what if” views. These show a light year, a heavy year, the worst case where you hit the out-of-pocket maximum, the point where the cheaper plan would stop being cheaper, month-by-month HSA cash flow, and a five-year projection if you invest the HSA balance. You can change your contribution, tax rate or premiums in the workbook and watch the numbers update.

The gap between a PPO and an HSA plan can be several thousand dollars a year. The choice between two HSA plans is often closer, and which one comes out ahead can depend on whether you have a light year or a heavy one. That’s the kind of thing you only see when you run your own numbers.

How it handles your data

Keeping medical records private was a design goal from the start, but it helps to be clear about what goes where. There are two parts:

Local tools. The scripts that read your claims, remove personal details and run the cost model work on your own computer. They don’t make network calls, and because the code is open source, you can check that yourself.
The AI assistant. If you use it, your conversation goes to the assistant’s cloud AI model. That includes what you type, like who’s on your plan and your tax bracket, and the de-identified counts and totals the local tools print. The local tools are what keep names, IDs, doctors, drugs and exact dates out of that stream.

Here’s what the project does to protect your data, and where its limits are:

The output files are built from a short list of allowed fields. That keeps names, IDs, doctors and exact dates out by design.
A leak scan checks the finished files against your original records (and against any private words you add, like your street name) before you share them. It’s a safety net that catches common mistakes. It can’t promise to catch everything.
A check in the code repository helps prevent real medical files from being committed by accident.
The skill tells the assistant not to open your claim files and to rely on the local tools instead. That’s an instruction to the AI model, not a technical barrier. Don’t paste claims, statements or screenshots into the chat, and check your AI provider’s data policies.

No tool can guarantee perfect privacy or security. This one is designed to limit how much personal information gets exposed, and you can review the code to see exactly what it does.

How to use it

The easiest way is to let an AI coding assistant guide you. Download the project and open its folder in an assistant that supports agent skills. GitHub Copilot in VS Code and Claude Code both find the skill on their own, so there’s nothing to install. Run the assistant on your own computer with the project folder open. Uploading the skill to a chat website doesn’t work here, because the tools that strip out personal details have to run on your machine.

Then ask something like:

Should I switch to an HSA plan? Walk me through it.

The assistant asks a few questions at a time: who’s on your plan, which plans you can choose, your rough tax bracket. Then it tells you exactly what to download and where to find it. You don’t need to know any of this in advance, or have every file. It works with:

claim downloads from your insurer’s website (the README lists which insurers’ exports work out of the box, and the assistant can convert other insurers’ spreadsheets),
EOB statements, or claims you type into a simple template,
nothing at all, in which case it builds an estimate from a short chat about how often your family sees a doctor.

If you’d rather do it yourself, the project README lists the five commands to run.

Want to see how it works before using your own data? The skill has a demo mode that walks you through the whole process with a fictional family. Example 2 below shows how to start it.

Example 1: what a recommendation looks like (hypothetical)

This first example is hypothetical. The Rivera family and every number below are made up for illustration, and none of it was produced by running the tool. For real tool output, skip to Example 2.

The Rivera family is two parents and two kids. They’re on a PPO and can switch to one of two HSA plans next year. After the assistant gathered their last two years of claims and the plan details, it came back with this:

Net yearly cost	Current PPO	HSA Plus	HSA Basic
A year like last year	$8,400	$4,900	$3,700
A heavier year (like the year before)	$9,300	$6,500	$6,900
Worst case (out-of-pocket max reached)	$10,900	$9,600	$8,800

Net cost = premiums + what you pay for care − the employer’s HSA deposit − tax savings.

And the recommendation, in plain words:

Switch to HSA Basic and contribute through payroll. It would have saved you about $4,700 last year compared with your PPO, and it’s still cheaper than the PPO in a heavy year and in the worst case. HSA Plus only pulls ahead in years when several of you need a lot of care, and even then by about $400.

Before you enroll, check three things:

Keep about $3,000 in savings for early-year bills. Your HSA builds up with each paycheck, but January is when the deductible hits.

Make sure your kids’ doctors are in the new plan’s network.

You can only spend HSA money tax-free on yourself, your spouse and your tax dependents.

How confident is this? Replaying your current PPO matched what you actually paid within 3% for both years, so the model understands your bills well. The one estimate in here is your teenager’s prescriptions, which you couldn’t see online.

Example 2: a real run of the skill in demo mode

Unlike the Rivera example, this one is real. The skill has a demo mode that runs the whole workflow on a fictional family of four, with synthetic claim exports and EOB PDFs and two fictional plans. No real medical data is involved, so you can see how the skill works before you gather your own documents.

To try it, clone the repository, set up its Python environment as the README describes, and open the folder in an agent that supports skills (GitHub Copilot in VS Code or the Copilot CLI, or Claude Code). Then ask:

Walk me through the HSA decision with the demo family.

The agent takes about 10-15 minutes and runs the same five phases it would run on your data:

Interview. It asks the usual questions, with the demo family’s answers pre-filled as defaults. You can accept them or change one, such as your state tax rate or HSA contribution, and watch the change carry through.
Plans. It reads a fictional benefits summary and checks the plan details against it.
Claims. It extracts the synthetic claims, goes through the two flagged rows with you and runs the leak scan.
Comparison. It runs the cost model and checks that replaying the current plan matches what the family actually paid.
Result. It explains the workbook, then tells you what to gather for a run on your own data.

It follows the same privacy rules as a real run. For example, it never opens the claim files and works only from the counts and totals that the local tools print. Everything goes into demo/output/, not the folder your real files would use.

With the default answers, this is the Annual comparison sheet of the workbook the run produces:

Synthetic family and fictional plans. The two examples are unrelated, so their numbers don’t match. If you change an interview answer, your numbers will differ from these.

In this demo the example HDHP costs about $4,790 less than the example PPO. The family pays about $2,707 more at the doctor and pharmacy, but premiums are about $5,200 lower, and the employer’s HSA money and the tax savings more than cover the difference. With other plans and other claims, the answer can flip.

If you only want to see the result:

Open the finished workbook. Download hsa_comparison_demo_recalculated.xlsx from the v0.1.0 pre-release, open it in Excel or LibreOffice and start on Annual comparison.
Skip the agent. Run python demo/run_demo.py. It builds the same workbook in a few seconds, without the guided walkthrough.

The demo mode is documented in the demo README. It was added after the v0.1.0 pre-release, so use the main branch to get it. The pre-release is marked that way because the tool is still experimental alpha software.

A few honest caveats

This is experimental alpha software. Expect rough edges, and please report anything that looks wrong. It’s a decision aid, not financial, tax or insurance advice, and every number it produces is an estimate. It assumes your doctors and negotiated prices stay the same on every plan. The automatic PDF reading only understands one insurer’s EOB format today (see the README for which); other insurers work through spreadsheet downloads, manual entry or estimates. Health care is also unpredictable, which is why the workbook shows you the bad years as well as the typical one.

The project is free and open source under the MIT license. You can find it on GitHub at ashtewari/hsa-vs-ppo. If it helps you make your choice this open enrollment, I’d love to hear about it.

Finance on Ash Tewari