WTFee

Inspiration

Three months ago, I ended up in the emergency room. Nothing life-threatening, but scary enough that I didn't ask questions when they ordered tests. A CT scan here, an MRI there, bloodwork, three nights in a semi-private room. I just wanted to feel better.

Then the bill came. $12,461.94.

I stared at it for twenty minutes trying to understand what I was looking at. CPT codes. Facility fees. "Medically Unlikely Edit Write-Offs." Charges that ranged from $486 to $6,532 with no explanation of what any of it meant. I'm not stupid, but this bill made me feel helpless.

I did what most people do. I put it in a drawer and tried not to think about it.

But the numbers wouldn't leave my head. $12,461. That's more than my car is worth. That's a semester of tuition. That's two years of rent. And I had no idea if it was even correct. Was $3,692 for an MRI reasonable? Should the emergency room really cost $4,334? What the hell is a "chargemaster rate"?

Then I found out I'm not alone. 72 million Americans are drowning in medical debt they don't understand. 40% of us can't read our own medical bills. We get these documents designed to confuse us, written in a language we were never taught, demanding money we might not even owe. And we just... pay it. Or ignore it until it destroys our credit. Because what else can we do?

That's when I decided to build something. Not for a grade. Not for my portfolio. For me. And for everyone else who's ever felt that same sick feeling opening an envelope from a hospital billing department.

What it does

WTFee translates medical bills into plain English. You upload a photo or PDF of your bill, and the app breaks down every single line item into language you can actually understand. Not just what the medical code means, but why you were charged, what it should cost, and what you can do about it.

The interface starts dark and unsettling because that's what looking at a confusing medical bill feels like. Harsh shadows. Flickering text. A sense of instability. But as you work through each charge and start to understand what you're actually being billed for, the interface transforms. The shadows lift. The colors warm. By the time you reach your final summary, the whole experience feels calm and manageable.

Because that's the point. Medical bills are terrifying when you don't understand them. WTFee turns confusion into clarity, and anxiety into agency.

For my actual $12,461 bill, WTFee explained that the "Self-Pay Discount" wasn't a favor but standard practice because hospitals inflate prices knowing insurance companies will negotiate down. It flagged my $3,692 MRI as 15-25% above the Cincinnati regional average and told me exactly who to call to dispute it. It caught the "Medically Unlikely Edit Write-Off" and explained that this meant the hospital had billed something incorrectly and caught their own error, which meant there might be other mistakes I should investigate.

Most importantly, it told me I likely qualified for charity care based on my income and gave me the exact steps to apply, including the phone number and what to say. Not vague advice. Actionable information that could save me thousands of dollars.

How we built it

I built WTFee with Kiro over five days, starting with comprehensive specs that mapped out every feature before writing a single line of code. The tech stack is React with TypeScript for the frontend, AWS Textract for document extraction, and Claude API for the AI-powered explanations.

The haunted UI transformation is built with Framer Motion for smooth animations and CSS overlays for the fog and flickering effects. Every visual element is tied to the user's progress through understanding their bill. As you click through explanations, the theme state updates and the entire interface gradually shifts from haunted to relieved.

The AI prompting is where the real intelligence lives. I engineered prompts that don't just explain medical terminology but provide regional cost context, detect potential billing errors, identify negotiable charges, and generate specific action items with phone numbers and scripts. The system analyzes each line item against typical costs, flags outliers, and explains the financial assistance options specific to your hospital system.

I used Kiro's spec-driven development to architect the core functionality, then switched to vibe coding for the visual polish and haunted effects. Agent hooks automatically ran tests on every save and validated my AWS infrastructure changes before deployment. The entire .kiro directory documents this process, showing how I used steering docs to keep Kiro focused on the Halloween theme while maintaining production-quality code.

Challenges we ran into

The biggest challenge was making the haunted UI transformation feel authentic rather than gimmicky. Medical bills ARE terrifying. The horror isn't fictional. I didn't want to slap cartoon ghosts on a dark background and call it spooky. I wanted the interface to reflect the genuine anxiety of not understanding what you owe, and then show the relief of finally getting answers.

Balancing that emotional journey with accessibility was hard. The fog effects and flickering needed to be atmospheric but not triggering for users with motion sensitivity. I implemented full support for prefers-reduced-motion and ensured color contrast remained compliant even in the darkest haunted state.

The AI prompting was more complex than I expected. Generic explanations weren't good enough. I needed the system to understand medical billing at a deep level, compare costs against regional averages, detect billing patterns that suggest errors, and generate actionable next steps that were specific to the user's situation. That required extensive prompt engineering and testing against real bills.

Getting AWS Textract to reliably extract structured data from medical bills was also challenging because every hospital formats bills differently. I ended up building a parser that could handle various layouts and still identify line items, costs, and adjustment codes with high confidence.

Accomplishments that we're proud of

I'm proud that I built something I actually needed. This isn't a toy. This isn't a technical demo for the sake of showing off a new API. This is a tool that could save me and millions of others thousands of dollars in medical debt.

I'm proud of the emotional design. The haunted-to-calm transformation isn't decoration. It's intentional UX that acknowledges how terrifying medical bills feel and provides a sense of progression and relief as understanding grows. That took real thought and iteration to get right.

I'm proud that the AI explanations are genuinely useful. When I ran my actual $12,461 bill through the system, I learned things I didn't know. I found potential savings I hadn't noticed. I got contact information and scripts I would have spent hours researching on my own. The app delivered real value.

I'm proud of the technical execution. Clean TypeScript throughout. Comprehensive test coverage. Proper AWS infrastructure with CDK. Agent hooks automating my workflow. A rich .kiro directory showing genuine spec-driven development. This is production-quality code built in five days because Kiro handled the boring parts while I focused on the parts that matter.

Most of all, I'm proud that I finished it. I could have given up when I saw the competition. I could have compromised on the haunted effects to save time. I could have cut corners on the AI intelligence. But I didn't. I built the thing I set out to build, and it works.

What we learned

I learned that specs actually matter. I used to think they were bureaucratic overhead, but having a comprehensive requirements doc and task breakdown meant I always knew what to do next. No decision paralysis. No wasted time. Just clear execution.

I learned that emotional design is hard but worth it. Making the UI transformation feel authentic required constant iteration and feedback. But when it works, when the interface actually makes users feel the shift from anxiety to relief, that's when software becomes more than just functional. It becomes meaningful.

I learned that AI prompting is an art form. Getting Claude to provide genuinely useful explanations rather than generic summaries required understanding exactly what information people need, how to structure that information, and how to make it actionable. The difference between "this is a CT scan" and "this is why they ordered a CT scan, what it should cost in your area, and whether this charge is negotiable" is everything.

I learned that vulnerability matters. I could have built a generic "medical bill explainer" for some hypothetical user. Instead, I built it for me, using my actual bill, solving my actual problem. That specificity made the product better. It made the story real. And it made me care enough to finish.

Most importantly, I learned that hackathons aren't about building the most technically impressive thing. They're about building something that matters. Something people need. Something that makes judges say "I would use this right now."

What's next for WTFee

If this gets traction, the obvious next step is expanding the medical code database and regional cost data. Right now I'm using AI to estimate typical costs, but partnering with healthcare pricing transparency APIs would make the cost comparisons definitive rather than approximate.

I want to add a dispute letter generator that creates templated letters you can send directly to billing departments. Not just "here's what to say" but "here's a formatted, legally sound letter you can mail today."

Long term, this could become a full medical billing advocacy platform. Upload your bill, get the analysis, connect with human advocates who can negotiate on your behalf. The AI does the analysis, humans do the phone calls. Most people don't have time to spend hours on hold with billing departments. But if we could streamline that process and show them exactly what to fight for, we could save people millions in erroneous charges.

The bigger vision is making healthcare billing transparent. Every hospital should be required to provide bills in a machine-readable format. Every patient should be able to upload their bill and immediately understand what they owe and why. The fact that this tool needs to exist is an indictment of the healthcare system. But until that system changes, people need help. And WTFee gives them that help.

I also want to open source the core bill parsing logic so other developers can build on this. Medical billing transparency is too important to keep locked up. If this project helps inspire better tools, better policies, or just helps one person successfully dispute an overcharge, it will have been worth building.

But honestly, if all this does is help me understand my own bill and save a few thousand dollars, that's still a win. Because that's what this was always about. One person, one bill, one problem that needed solving. Everything else is just scale.

Built With

• aws-cdk
• aws-textract
• claude-api
• framer-motion
• kiro
• react
• styled-components
• typescript
• vite