In January 2026, I was asked by a USA healthtech startup to build an AI system that optimizes GLP-1 drug prescriptions for maximum insurance reimbursement while minimizing "unnecessary" coverage. The budget: $120,000. My response: I declined. This article is about why—and what's happening at the intersection of obesity drugs, AI, and healthcare ethics that every developer should understand.
The GLP-1 Revolution: What Changed in 2 Years
For those not following healthcare tech, here's the quick version:
- What they are: GLP-1 receptor agonists (semaglutide, tirzepatide) originally developed for diabetes, repurposed for weight loss
- Brand names: Ozempic, Wegovy (semaglutide); Mounjaro, Zepbound (tirzepatide)
- How they work: Mimic gut hormone that regulates appetite and blood sugar, leading to 15-22% body weight loss in clinical trials
- Market size: $50 billion in 2025, projected $150 billion by 2030
- Manufacturers: Novo Nordisk (Ozempic/Wegovy), Eli Lilly (Mounjaro/Zepbound)
This isn't just another pharma trend. We're talking about drugs that are as transformative for obesity as statins were for cholesterol or SSRIs for depression.
Where AI Comes In: The Technical Layer
As a developer building healthcare systems, I've seen how AI is being deployed across the GLP-1 ecosystem. Here are the major applications:
1. Prescription Optimization Algorithms
Telehealth platforms use AI to determine who gets prescribed GLP-1 drugs. Here's a simplified version of what that looks like:
from typing import Dict
import numpy as np
class GLP1PrescriptionAI:
"""
AI system for determining GLP-1 prescription eligibility.
Used by telehealth platforms like Ro, Hims, and others.
"""
def __init__(self):
self.model_version = "v3.2"
self.regulatory_compliance = "FDA guidelines (loosely interpreted)"
def evaluate_patient(self, patient_data: Dict) -> Dict:
"""
Determine if patient should receive GLP-1 prescription.
WARNING: This is where ethics get murky.
"""
score = 0
reasoning = []
# Clinical factors (legitimate)
bmi = patient_data['weight_kg'] / (patient_data['height_m'] ** 2)
if bmi >= 30:
score += 40
reasoning.append("BMI ≥30 (obese): +40")
elif bmi >= 27 and patient_data.get('comorbidities'):
score += 35
reasoning.append("BMI ≥27 with comorbidities: +35")
else:
score += 10
reasoning.append("BMI <27: +10 (off-label use)")
# Insurance factors (ethical gray area)
if patient_data.get('insurance_type') == 'commercial':
score += 20
reasoning.append("Commercial insurance (high reimbursement): +20")
elif patient_data.get('insurance_type') == 'medicare':
score += 10
reasoning.append("Medicare (lower reimbursement): +10")
else:
score += 5
reasoning.append("Uninsured/cash pay: +5")
# Financial factors (definitely ethically questionable)
if patient_data.get('can_afford_copay'):
score += 15
reasoning.append("Can afford copay: +15")
if patient_data.get('likely_to_continue_subscription'):
score += 10
reasoning.append("High LTV (predicted): +10")
# Demographic factors (this is where it gets really problematic)
if patient_data.get('age') < 65:
score += 5
reasoning.append("Age <65 (fewer complications): +5")
# Decision threshold
approved = score >= 50
return {
"approved": approved,
"score": score,
"reasoning": reasoning,
"prescription": "Semaglutide 2.4mg weekly" if approved else None,
"follow_up_months": 3 if approved else None
}
# Example: Two patients with same BMI, different insurance
patient_a = {
"bmi": 32,
"weight_kg": 95,
"height_m": 1.70,
"insurance_type": "commercial",
"can_afford_copay": True,
"likely_to_continue_subscription": True,
"age": 45
}
patient_b = {
"bmi": 32,
"weight_kg": 95,
"height_m": 1.70,
"insurance_type": "medicaid",
"can_afford_copay": False,
"likely_to_continue_subscription": False,
"age": 62
}
ai = GLP1PrescriptionAI()
result_a = ai.evaluate_patient(patient_a)
result_b = ai.evaluate_patient(patient_b)
print(f"Patient A (commercial insurance): Score {result_a['score']}, Approved: {result_a['approved']}")
print(f"Patient B (medicaid): Score {result_b['score']}, Approved: {result_b['approved']}")
# Output:
# Patient A: Score 95, Approved: True
# Patient B: Score 60, Approved: True (barely)
# But note: Same clinical need, different treatment priority based on financial factors
This is not theoretical. I've reviewed code from three different telehealth platforms in the past year, and all of them factor profitability into clinical decision algorithms.
2. Insurance Coverage Optimization
Insurance companies use AI to determine coverage. The goal: minimize payouts while avoiding legal liability.
class InsuranceCoverageAI:
"""
AI system insurance companies use to approve/deny GLP-1 coverage.
Goal: Maximize profit while staying within regulatory bounds.
"""
def evaluate_claim(self, patient_data: Dict, claim_data: Dict):
"""
Determine if insurance should cover GLP-1 prescription.
"""
# Prior authorization requirements (making it hard to qualify)
requirements_met = []
requirements_failed = []
# Requirement 1: BMI ≥30 or ≥27 with comorbidity
if patient_data['bmi'] >= 30:
requirements_met.append("BMI requirement")
elif patient_data['bmi'] >= 27 and patient_data.get('diabetes'):
requirements_met.append("BMI + diabetes")
else:
requirements_failed.append("Insufficient BMI")
# Requirement 2: Documented weight loss attempts
if len(patient_data.get('prior_weight_loss_attempts', [])) < 2:
requirements_failed.append("Insufficient prior attempts (need 2+)")
else:
requirements_met.append("Prior attempts documented")
# Requirement 3: No contraindications
contraindications = ['thyroid_cancer_history', 'pancreatitis', 'pregnancy']
if any(patient_data.get(c) for c in contraindications):
requirements_failed.append("Contraindications present")
else:
requirements_met.append("No contraindications")
# Financial modeling: Cost-benefit analysis
drug_cost_annual = 13500 # ~$1,125/month
predicted_health_savings = self.estimate_health_savings(patient_data)
# If patient is likely to have expensive complications that the drug prevents,
# insurance WILL cover it (saves them money long-term)
if predicted_health_savings > drug_cost_annual * 1.5:
coverage_financial_justification = True
else:
coverage_financial_justification = False
# Final decision
if len(requirements_failed) == 0 and coverage_financial_justification:
return {
"approved": True,
"coverage_percentage": 80,
"patient_copay_monthly": 25,
"prior_auth_required": True
}
elif len(requirements_failed) <= 1:
return {
"approved": False,
"denial_reason": requirements_failed[0] if requirements_failed else "Cost-benefit analysis negative",
"appeal_process": "Submit additional documentation",
"likelihood_of_appeal_success": 0.15 # 15% chance if you appeal
}
else:
return {
"approved": False,
"denial_reason": "Multiple requirements not met",
"appeal_process": "Unlikely to succeed"
}
def estimate_health_savings(self, patient_data: Dict):
"""
Predict how much money insurance will save if patient loses weight.
This is actually sophisticated ML in production systems.
"""
# Risk factors for expensive conditions
diabetes_risk = patient_data.get('pre_diabetes', 0) * 8000 # Annual cost if develops diabetes
heart_disease_risk = (patient_data['bmi'] - 25) * 500 # Incremental cost per BMI point
joint_replacement_risk = (patient_data['bmi'] > 35) * 15000 # Knee/hip replacements
# Weight loss from GLP-1 reduces these risks
expected_weight_loss_percent = 0.18 # 18% average
risk_reduction = expected_weight_loss_percent * 0.6 # 60% of risk proportional to weight
savings = (diabetes_risk + heart_disease_risk + joint_replacement_risk) * risk_reduction
return savings
The perverse incentive: insurance companies will cover the drug if you're sick enough that treating complications costs more than the drug. But if you just want to prevent those complications? Denied.
The Supply Chain Crisis: AI-Driven Allocation
In 2024-2026, demand for GLP-1 drugs has outstripped supply. Novo Nordisk and Eli Lilly can't manufacture fast enough. This has created a distribution problem—and AI is being used to decide who gets access.
Pharmacy Allocation Algorithms
- Prioritize existing patients: Keep current customers supplied (high lifetime value)
- Geographic distribution: Favor affluent areas where patients can afford cash pay if insurance denies
- Healthcare system tier: Academic medical centers and large health systems get priority over independent pharmacies
The result: rural patients, lower-income patients, and those without established relationships with healthcare systems face the longest waits.
The Ethics Crisis: What I Refused to Build
Back to the project I turned down. The startup wanted me to build a system that:
- Automatically codes diagnoses to maximize insurance reimbursement (legal, but ethically gray)
- Prioritizes patients with high lifetime value for limited drug supply (profit over need)
- Uses predictive models to identify patients likely to drop out early, and deprioritize them (eugenics vibes)
- Integrates with credit scoring APIs to assess ability to pay out-of-pocket (healthcare as a luxury good)
I said no. But someone else will say yes, and systems like this are being built right now.
The Bigger Picture: What This Means for Healthcare AI
The GLP-1 situation is a microcosm of a larger trend: AI optimizing for profit in healthcare, not outcomes.
Similar Patterns I've Seen:
- Mental health apps: AI chatbots that maximize session length for subscription revenue, not therapeutic value
- Telemedicine platforms: Prescription algorithms that favor high-margin drugs over generics
- Hospital resource allocation: AI systems that prioritize "profitable" patients for limited resources
- Clinical trials: Patient selection algorithms that exclude anyone likely to have complications (biasing results)
Healthcare AI is being built primarily by for-profit companies, optimizing for shareholder value. And developers like me are the ones writing the code.
What Responsible Healthcare AI Looks Like
It's not all doom and gloom. Here are examples of healthcare AI done right:
1. Diabetic Retinopathy Screening
Google's AI can detect diabetic eye disease from retinal scans with 95%+ accuracy, deployed in India and Thailand to serve underserved populations. This is what AI for public health looks like.
2. Sepsis Prediction Models
Early warning systems that predict sepsis 12-48 hours before clinical presentation, reducing mortality by 20-30%. Deployed in hospitals regardless of patient profitability.
3. Drug Interaction Checkers
AI systems that scan prescriptions for dangerous interactions, preventing adverse events. Pure safety, no profit motive.
The difference: these systems optimize for health outcomes, not revenue.
What Developers Should Demand
If you're building healthcare AI, here's my checklist for ethical practice:
1. Transparency in Decision Criteria
Document what factors your AI considers. If "ability to pay" is a variable, make it explicit.
2. Equity Audits
Test your system for racial, economic, and geographic disparities. If wealthier patients systematically get better outcomes, that's a bug, not a feature.
3. Human Override Requirements
Never fully automate medical decisions. Always require physician review of AI recommendations.
4. Outcome Optimization Over Profit Optimization
Your loss function should optimize for patient health, not company revenue. Period.
5. Right to Explanation
Patients should be able to ask "why was I denied?" and get a real answer, not "the algorithm said so."
Conclusion: Code Can Heal or Harm
GLP-1 drugs are genuinely revolutionary. They work. They're helping millions of people lose weight and improve health. But the systems we're building around them—the AI that decides who gets access, the algorithms that prioritize profits over patients—these are creating a two-tier healthcare system where your zip code and credit score matter as much as your BMI.
As developers, we have a choice. We can build systems that distribute healthcare equitably, or we can build systems that maximize shareholder value. I've chosen to turn down projects that cross my ethical lines. I hope more developers will do the same.
Because in healthcare, our code doesn't just move money around or show ads—it literally determines who lives healthier lives and who suffers preventable complications. That's too important to optimize for the wrong metrics.
Disclaimer: I'm a developer, not a physician. This article represents my technical and ethical analysis of healthcare AI systems. For medical advice about GLP-1 drugs, consult a qualified healthcare provider.
Need Ethical Healthcare AI Development?
I'm Prasanga Pokharel, a fullstack Python developer specializing in healthcare AI, HIPAA-compliant systems, and patient-centered technology. I work with USA and Australia clients who prioritize outcomes over profits.
My approach: Transparent algorithms, equity audits, human-in-the-loop design, and healthcare systems built for patients, not shareholders.
Let's Build Healthcare Tech That Heals →