Why Your Health Insurance Isn't Safe
The ACA failed both sides because policy debates can't solve architecture problems
On January 1, 2026, health insurance premiums spiked an average of 114% for Americans buying coverage on the exchanges. Enhanced subsidies that had kept costs manageable expired on December 31st. Over a million people dropped coverage in the first three weeks of the year.
If you’re one of them, you just watched affordable healthcare vanish overnight. Not because you did anything wrong. Because Congress didn’t reauthorize temporary subsidies. Again.
This is the third time in fifteen years healthcare coverage has lurched. The ACA passed in 2010—individual mandates, employer thresholds, exchange requirements locked into federal law. Courts challenged it. Republicans tried to repeal it. The individual mandate got eliminated. States opted out of Medicaid expansion. Then the pandemic hit and Congress added enhanced subsidies. They worked—the uninsured rate dropped to a record low of 7.9% in 2022. Then Congress let them expire.
Healthcare instability is not a policy disagreement. It is governance architecture failure.
Now we’re climbing back toward 31 million uninsured by 2027.
Six months before the premium spike, Congress passed the “One Big Beautiful Bill” through budget reconciliation. New work requirements for Medicaid eligibility. Stricter income verification for subsidies. Specific hour thresholds. Specific qualifying activities. States scrambling to build compliance systems by late 2026. The gaming has already started—what counts as work, how to report hours, which activities qualify.
This is governance architecture failure.
Healthcare policy whiplash. Coverage expands, contracts, gets challenged in court, re-litigated in Congress, modified by reconciliation, reversed again. Families cannot plan more than one election cycle ahead. Businesses cannot forecast compliance costs beyond one administration. Employers keep workers at 29 hours to avoid the 30-hour threshold. States manipulate work-hour definitions to hit federal requirements.
Every four to eight years, we tear it down and start over.
The Right hates the prescriptive mechanisms—rigid federal mandates, arbitrary thresholds, one-size-fits-all rules that ignore local differences. The Left is frustrated it never delivers adequate coverage—compromises water down goals before implementation begins, temporary fixes substitute for permanent solutions.
Both critiques are valid. The system is simultaneously too prescriptive where it should be flexible and inadequate where it should be robust.
Here’s what’s actually broken: we’re asking democratic policy-making to do institutional design work it’s not built to do. Congress doesn’t just set goals—it specifies mechanisms. Fifty employees exactly. Thirty hours exactly. Work requirements with detailed qualifying activities. Premium subsidies that phase out at specific income levels. These aren’t evidence-based specifications. They’re political compromises locked into federal law.
The result is predictable. Amateur engineering creates perverse incentives. Rigid mechanisms prevent adaptation. When problems emerge, fixing them requires passing new legislation through gridlock. Meanwhile, the goals themselves get compromised to secure votes—no public option, state opt-outs, industry carve-outs, temporary instead of permanent funding.
You end up with systems that don’t work well, can’t be fixed, and lurch with every election.
The January 2026 premium spike demonstrates the pattern. Enhanced subsidies worked—coverage became affordable, the uninsured rate dropped. But they were designed as temporary, with a built-in expiration date requiring congressional reauthorization to continue existing. One Congress fails to act, the program dies. A million people lose coverage in three weeks.
That’s not healthcare policy dysfunction. That’s structural failure. There’s a difference between annual appropriations review—where Congress checks if programs are working and adjusts funding levels—and temporary programs that cease to exist without reauthorization. The first is accountability. The second is fragility. We built healthcare subsidies as a temporary measure instead of permanent architecture, making sustainability dependent on continuous political renewal.
This keeps happening because we’re confusing two fundamentally different types of work.
The Pattern: Prescriptive Mechanisms That Don’t Achieve Goals
The ACA locked specific mechanisms into federal law. Employer mandates at exactly 50 employees, exactly 30 hours. Individual mandates with specific penalties. Exchange structures with detailed requirements. These weren’t evidence-based specifications—they were political compromises.
Result: Employers game the thresholds, keeping workers at 29 hours or 49 employees. When healthcare.gov implementation encountered problems, the law’s specificity prevented adaptation without going back to Congress. Mechanisms became political targets. The individual mandate got repealed, undermining the system’s logic. Nothing can be fixed without passing new legislation through gridlock.
The July 2025 “One Big Beautiful Bill” repeated the pattern. New work requirements for Medicaid—specific hour thresholds, specific qualifying activities, specific state implementation deadlines. Locked into law through budget reconciliation. States now scrambling to build compliance systems by late 2026. The gaming has already started: what counts as “work,” how to report hours, which activities qualify.
Too prescriptive: rigid federal mechanisms that create perverse incentives, prevent adaptation, and become political targets.
But simultaneously, didn’t go far enough.
The ACA’s goals were to expand coverage and make healthcare affordable. The individual mandate was designed to get healthy people into the risk pool, making insurance economically viable. Democratic compromise watered it down—no public option (industry pressure), state Medicaid opt-outs (political compromise), industry carve-outs (pharma, insurance companies).
The system achieved a record low uninsured rate of 7.9% in 2022, but that relied on enhanced subsidies that were always temporary. When they expired December 31, 2025, over a million people dropped coverage in three weeks. The uninsured rate is climbing back toward 31 million.
The architecture was fragile by design. Temporary subsidies instead of sustainable funding. Political reauthorization required to keep them. One Congress fails to act, the whole thing collapses.
Every stakeholder got concessions. Every interest group secured exceptions. What passed was what could get votes, not what would reliably achieve the goals of expanded, affordable coverage.
Both critiques are valid. The system is prescriptive where it should be flexible—locked mechanisms preventing adaptation. And inadequate where it should be robust—goals compromised away, funding fragile, coverage unstable.
This isn’t partisan dysfunction. This is what happens when you try to solve architecture problems through policy debates.
The Missing Distinction: What Policy Is For, What Architecture Is For
We’re confusing two fundamentally different types of problems.
Policy questions are normative. They’re about what we should want. Should we prioritize universal coverage? How do we balance cost versus access versus quality? What trade-offs between individual freedom and collective responsibility are acceptable? What values matter most?
These are questions democracy is designed to answer. Different people legitimately disagree. There’s no objectively correct answer. The answer should evolve as society evolves. Politicians are good at this—they’re trained in representation, coalition-building, balancing competing interests.
A good policy statement looks like this: “We want universal healthcare coverage that controls costs while maintaining quality of care.”
That’s it. That’s what Congress should provide. Democratic legitimacy for the goal. Clear direction about priorities. The rest is engineering.
Architecture questions are technical. They’re about how we actually achieve the goal. What institutional mechanisms deliver universal coverage? How do we prevent regulatory capture? What accountability structures ensure the system works? How do we adapt as circumstances change?
These are engineering questions. Better and worse answers exist. Politicians aren’t trained for this—they’re trained for representation, not systems design. Expertise matters. Like designing bridges: you don’t want amateurs doing the structural calculations.
Good architecture looks like this: a professionally designed institutional system that could be single-payer like the UK, regulated multi-payer like Germany, or a public-private hybrid like various other models. The key is that it’s engineered to actually work—clear mechanisms, accountability structures, feedback loops—not compromised into dysfunction.
Think about city planning versus bridge engineering.
City planning is policy: Where should we build bridges? Which neighborhoods need them? What’s the budget priority? These are democratic questions. Values, trade-offs, representation.
Bridge engineering is architecture: How do we design this specific bridge to support the load without collapsing? This requires professional expertise. Structural calculations. Materials science. There are right and wrong answers.
You don’t democratically compromise on whether the bridge should support the load. You engineer it to specification, then democratically decide which bridges to build where.
The ACA tried to do both through democratic policy-making. Congress debated not just what goal to pursue, but exactly how to achieve it. Fifty employees or forty? Thirty hours or thirty-five? Individual mandate penalties of how much? What exchange requirements?
These are architecture questions being answered through political compromise. The result was predictable: mechanisms that don’t work well, locked into law, impossible to fix without another decade of political fighting.
We asked policy-making to do architecture’s job. Policy-making produced exactly what it’s designed to produce: compromise, stakeholder buy-in, democratic legitimacy. But compromise isn’t how you engineer working systems. And democratic process isn’t how you design robust institutions.
What It Should Look Like: Proper Separation of Concerns
Here’s what proper governance architecture would look like for healthcare.
Congress sets the policy goal: “We want universal healthcare coverage that controls costs while maintaining quality of care.”
That’s the democratic input. Clear goal. Value judgment about priorities. Can evolve if society’s priorities change. Politicians doing what they’re good at—representing interests, making normative choices, providing democratic legitimacy.
What Congress does not do: specify individual mandates, set employee thresholds, design exchange mechanisms, amateur engineering of implementation details.
The Governance Design Agency—a constitutional-level institution separate from Congress—would handle the architecture. Multi-member board serving staggered terms, insulated from electoral cycles like the Federal Reserve Board of Governors. Professional staff with expertise in institutional design, health policy, economics, systems engineering. Their mandate: design systems that achieve stated policy goals.
The GDA’s constraint is structural, not substantive: it designs systems to achieve stated policy goals, but cannot set those goals. Congress says “expand coverage” or “control costs” or “improve quality”—those are democratic choices. The GDA designs the institutional mechanisms that reliably achieve them.
Democratic accountability operates through transparency and oversight, not micromanagement. The GDA submits proposed architectures to Congress. Congress votes to approve, reject, or request revisions. Board members can be removed for cause. The GDA reports quarterly on whether stated goals are being achieved—coverage rates, cost trends, quality metrics.
The critical protection: when Congress proposes modifications to the architecture, the GDA must transparently report whether those changes would mathematically undermine stated goals. If Congress wants to add “employers with 50+ workers” thresholds, the GDA reports: “This specification will create 29-hour gaming and reduce coverage by approximately X%.” Congress can still override—but they do so knowingly, accepting responsibility for breaking the engineering.
Congress can say “we want expanded coverage” or “try a different approach to achieving coverage expansion.” Congress cannot say “yes but only if employers with 50+ workers and only for employees working 30+ hours...” That kind of specification is what creates the 29-hour gaming, what locks rigidity into law, what makes the system brittle.
The GDA evaluates approaches based on evidence and designs the institutional mechanisms. Single-payer systems—strengths, weaknesses, implementation requirements. Regulated multi-payer systems—how different countries structure accountability and cost control. Public-private hybrids—what configurations prevent capture while maintaining efficiency. The analysis identifies which approach best achieves the stated goal.
Then: design the institutional architecture. How does coverage actually work? What accountability structures prevent insurance industry capture? What feedback loops measure whether goals are being achieved? What cost control mechanisms make it sustainable? Implementation roadmap with clear milestones and adjustment protocols.
The crucial difference from the ACA: mechanisms aren’t locked into legislation. The GDA iterates based on outcomes. If something doesn’t work, fix it. If circumstances change, adapt. Professional design enables continuous improvement without requiring new laws.
That’s the key. Policy provides the goal and democratic legitimacy. Architecture provides the professional design that makes the goal achievable. Accountability ensures they stay aligned.
In practice, it would work like this.
Year one: Congress sets the goal of universal coverage. The GDA designs the institutional system and begins implementation. Clear measurements: coverage rates, cost trends, quality metrics.
Year five: Data shows coverage has been achieved, but cost control needs more work. Congress adjusts the policy goal: “Maintain universal coverage, prioritize cost control.” The GDA iterates the architectural design—adjusts payment structures, strengthens cost accountability mechanisms—without rebuilding the entire system.
This is impossible with the current model. Adjusting anything requires passing new legislation through a gridlocked Congress. It would take another decade of political fighting. The ACA is stuck with its 2010 compromise version because we locked mechanisms into law instead of building adaptive institutions.
Why This Actually Solves Both Problems
This approach avoids both failure modes.
It avoids “too prescriptive” because the law states a goal, not mechanisms. Implementation can adapt without requiring new legislation. No individual mandates to become political targets. No arbitrary thresholds creating gaming opportunities. Professional engineering replaces amateur design. The system can improve based on evidence instead of remaining frozen in its compromised initial state.
It avoids “didn’t go far enough” because the goal is stated clearly—universal coverage—and the architecture is designed to actually achieve it. No compromise on whether the system works. No watering down of the goal itself. Measured by outcomes, not compliance with specific mechanisms.
The bipartisan appeal becomes clear. Conservatives get less prescriptive federal law and a more professional, technocratic approach. Working markets with proper oversight instead of rigid mandates. Progressives get actual universal coverage without political compromise watering it down. Both sides get a working system instead of a political football.
This isn’t theoretical. We already do this for other critical functions—and it works.
The Federal Reserve separates monetary policy from electoral cycles. Congress sets the goal—price stability, maximum employment—but doesn’t specify interest rates or money supply targets. The Fed Chair serves a fixed term. Professional economists design the mechanisms. Markets trust the system precisely because it’s insulated from political whiplash.
The result: monetary policy that adapts to changing conditions without requiring new legislation, maintains credibility through democratic transitions, and delivers relatively stable outcomes compared to what we’d get from Congress trying to set interest rates directly.
The Surgeon General and CDC respond to public health emergencies with technical competence under democratic oversight. The NTSB sets transportation safety standards based on engineering analysis, not political compromise. These institutions work because we separate the policy question—what outcomes do we want?—from the architectural question—how do we reliably achieve them?
Healthcare policy should work the same way. The question isn’t whether we want expanded coverage—that’s a democratic choice voters can change. The question is: once we choose that goal, how do we build institutions that actually deliver it? That’s an engineering problem requiring professional architecture.
The Pattern Extends Beyond Healthcare
Healthcare policy whiplash—subsidies expire, premiums spike, coverage drops—demonstrates what happens when we confuse policy with architecture. Congress locks rigid mechanisms into law instead of building adaptive institutions. Goals get compromised to secure votes. Temporary fixes substitute for robust design. The result: instability, dysfunction, frustration on all sides.
This pattern isn’t unique to healthcare.
Financial regulation exhibits the same failure mode. Wall Street reform proposals are simultaneously too prescriptive—narrow rules targeting specific actors, arbitrary thresholds—and don’t go far enough—broader systemic problems untouched. Both conservatives and progressives recognize the dysfunction. Neither can fix it through policy debates.
Education reform repeats the pattern. Rigid federal mandates combined with inadequate solutions. Achievement gaps persist. Every administration tries again with the same tools, gets the same results.
Infrastructure, environmental regulation, trade policy—you’d find the identical failure mode everywhere we try to solve architecture problems through policy debates.
We don’t need to agree on the right healthcare policy to agree that policy shouldn’t lurch every four years. We don’t need consensus on universal coverage to recognize that a million people losing insurance in three weeks because subsidies expired represents structural failure, not healthy democratic debate.
We need professional governance architecture. That’s what the GDA provides. Not for healthcare specifically—for every domain where we’ve confused what we want with how we build it.
The January 2026 premium spike is the latest reminder that fragile policy isn’t a substitute for robust architecture. We can keep locking amateur engineering into law, compromising goals to get votes, fighting the same battles every election cycle. Or we can separate policy from architecture, let democracy set goals while professional design builds systems that reliably achieve them.
That’s what I would build. The architecture exists. The mechanisms work. Other democracies separate monetary policy from politics, safety standards from lobbying, public health response from electoral cycles. We can do the same for governance design itself.
Share the loading symbol. Demand professional governance architecture. Let’s build this.
Both parties do little to help us with sensible policy. Just like immigration, both parties prefer constant adversity. Actually creating equity, equality or good governance actually would require intelligence and ETHICAL leadership. Sigh.
Thanks you.