Why Democratic Compromise Can't Fix Structural Problems
Democratic compromise is vital for setting goals, but disastrous for engineering mechanisms
This week I published two essays on policy reform.
Monday: the Affordable Care Act — why it was simultaneously too prescriptive and didn’t go far enough, locking arbitrary thresholds into statute while leaving 25 million still uninsured. Wednesday: the Stop Wall Street Looting Act — why its two-year dividend delay sounded meaningful but could be routed around in an afternoon, and why the broader dysfunction it was meant to address remains untouched.
I didn’t discover the pattern by writing them. I broke a single long essay into three pieces specifically to let readers experience it — the same structural failure, two different domains, before naming it explicitly here. This is that third piece.
The pattern is always identical. We identify a real problem everyone can see. We debate solutions. We compromise, pass legislation, and declare progress. A few years later, both sides are equally frustrated. Conservatives say it was too prescriptive, too intrusive, didn’t respect market forces. Progressives say it didn’t go far enough, left the core problem untouched, got watered down by industry pressure.
Here’s what’s striking: both critiques are usually right. The ACA was too prescriptive AND didn’t go far enough. Dodd-Frank was too complex AND left systemic risk intact. No Child Left Behind created perverse incentives AND failed to close achievement gaps.
This isn’t coincidence. It’s a pattern. And the question worth asking isn’t “why did this specific bill fail?” It’s “why does every bill fail the same way?”
The answer is that we keep using the wrong tool for the job. But before I make that argument, I want to take seriously why the people writing these bills believe — not unreasonably — that they’re using the right one.
Why the Traditional Approach Makes Sense
There’s a conventional wisdom in legislative drafting, and it didn’t emerge from nowhere.
The lesson Washington has learned over decades of policy fights is this: vague mandates get captured. If Congress passes a law saying “achieve universal healthcare coverage through whatever mechanisms work best,” what happens next is that the insurance industry, the pharmaceutical lobby, and the hospital associations write the “whatever mechanisms work best” part. The regulatory process becomes a negotiation between organized interests. The vague mandate arrives at implementation and gets translated into rules that protect the incumbent players.
Political scientists call this “regulatory capture,” and it’s well-documented and genuinely destructive. Progressives lived through it with financial regulation in the 1990s. Conservatives have watched it happen with agencies they created. It’s not a partisan phenomenon — it’s a structural one.
So legislators learned: if you want something to actually happen, write it into the law. Lock it down. Make the mechanism specific enough that there’s no room for industry to rewrite it at the regulatory level. The thirty-hour threshold, the fifty-employee cutoff, the two-year dividend delay — these aren’t accidents of sloppy drafting. They’re attempts to leave as little discretion as possible to the administrative process that follows.
This logic isn’t wrong. Legislative specificity really does reduce the surface area for regulatory capture. Vague mandates really do get gutted in implementation. The instinct to lock mechanisms into statute is a rational response to a real problem that reformers have been burned by repeatedly.
Here’s the issue: the cure creates a different disease. And it’s just as fatal.
Two Different Problems, Two Different Tools
There’s a distinction that the legislative drafting instinct collapses — one that explains why specificity in statute both reduces one failure mode and guarantees another.
Some problems are policy problems: what goals should we pursue, what trade-offs are acceptable, what values should guide our decisions? These are normative questions. Reasonable people disagree. Democratic debate is exactly the right mechanism for resolving them. Compromise isn’t a weakness here — it’s how you build legitimate decisions from diverse interests.
Other problems are architecture problems: given that we’ve agreed on the goal, what institutional mechanisms actually achieve it? How do we design accountability structures that resist capture? How do we anticipate second-order effects and gaming responses? How do we build systems that remain robust as circumstances change?
These are technical questions. They require systems thinking, failure-mode analysis, and expertise in institutional design. Democratic debate is poorly suited to resolve them — not because democracy is bad, but because you can’t vote your way to a bridge that holds.
The traditional drafting instinct — write specific mechanisms into law to prevent regulatory capture — is solving a policy problem with the tools of architecture. But it’s doing the architecture badly, because legislative drafting isn’t engineering. And it’s creating a new problem in the process: mechanisms locked into statute that can’t adapt, can’t iterate, and can’t respond to what actually happens when implementation meets reality.
We’ve been choosing between two failure modes — vague mandates that get captured, and specific mechanisms that get locked — without recognizing that both failures come from the same root cause. We’re asking democratic process to do work that requires professional design. And neither version of that approach produces institutions that work.
The question isn’t “how specific should the legislation be?” The question is whether legislation is the right tool at all for the part of the problem we keep getting wrong.
How Policy Eats Architecture
When democratic process tries to do architecture work, four things happen reliably.
Compromise weakens the mechanism. Passing legislation requires building coalitions. Building coalitions requires giving stakeholders what they need to say yes. In a policy debate about values and priorities, this is exactly how it should work — different interests get represented, trade-offs get negotiated, the result has democratic legitimacy. But when you’re engineering a mechanism, compromise can destroy it. The ACA’s individual mandate was weakened until it lacked sufficient force to hold the risk pool together. The employer mandate threshold was set at fifty employees and thirty hours specifically because those were the numbers a coalition could agree on — not because they made engineering sense. The healthcare.gov implementation disaster came from procurement rules designed for political accountability, not technical competence. The compromises that made the bill passable made the mechanism fragile.
You don’t negotiate the specifications for load-bearing steel. The bridge either holds or it doesn’t.
Amateur design leaves gaps. Politicians are extraordinarily skilled at coalition-building, persuasion, and representing constituent interests. These are genuine and difficult skills. They are not the same as institutional design, systems thinking, or failure-mode analysis. The difference shows up in the details. The Stop Wall Street Looting Act’s two-year dividend delay sounds like a meaningful restriction on private equity extraction — until you notice that funds can simply structure exits at the two-year-and-one-day mark. The ACA’s 29-hour threshold for employer coverage was immediately exploited by businesses converting full-time positions to part-time. These aren’t unusual examples of legislative failure; they’re predictable consequences of having non-engineers design mechanisms.
Mechanisms get locked into legislation. The only way to get democratic buy-in is to specify mechanisms in the bill itself. You can’t pass “achieve universal coverage however works best” — you have to pass individual mandates, specific penalty structures, exchange requirements with defined parameters. Once those mechanisms are locked into statute, they can’t be adjusted without passing new legislation. Which, in a polarized environment, means they can’t be adjusted at all. The ACA’s individual mandate became a political target precisely because it was written into law — and once it was weakened, the surrounding architecture couldn’t adapt. Good institutional design requires iteration based on outcomes. Legislation prevents iteration.
Implementation through broken governance corrupts intent. Even a well-designed policy faces a final obstacle: it gets implemented through the same broken architecture that produced the problem in the first place. Regulatory agencies subject to capture by the industries they regulate. Enforcement priorities that shift with each administration. Revolving door between regulators and regulated. No institutional memory across personnel changes. The policy intent arrives at the implementation layer and encounters a system that systematically degrades it. Not because anyone is villainous, but because the implementation infrastructure is itself poorly designed.
This is the policy trap in its full form. Democratic process produces legislation with weakened mechanisms, amateur engineering, locked-in specifications, and implementation through captured agencies. Then we’re surprised when the structural problem persists.
What Policy Should Actually Do
Here’s what gets lost in this: policy is valuable. Democratic debate about goals and values is not just necessary for legitimacy — it’s genuinely the right mechanism for those questions.
When we ask whether America should prioritize universal healthcare coverage, or how to balance environmental protection against economic development, or what trade-offs are acceptable between worker protection and capital flexibility — these are normative questions. They’re questions about what kind of society we want. Different people have legitimate different answers. The democratic process exists precisely to aggregate those preferences, build consensus, and produce legitimate decisions.
Good policy sounds like: “We want universal healthcare coverage.” “We want workers protected from predatory financial practices.” “We want quality education accessible to every child regardless of zip code.”
Notice what these statements do and don’t contain. They articulate goals. They establish priorities. They reflect democratic values. What they don’t do is specify implementation mechanisms, set arbitrary thresholds, or amateur-engineer complex institutional systems. That’s not a weakness in these statements. That’s what makes them appropriate policy.
The problem isn’t that policy sets goals. The problem is that policy tries to specify architecture, and does it badly.
The Separation That Would Fix This
The solution is proper separation of concerns — a principle any systems engineer would recognize immediately.
The policy layer is democratic. Congress, representing the public, sets goals and priorities. “We want universal coverage controlling costs.” “We want domestic manufacturing capacity in strategic sectors.” “We want campaign finance that doesn’t corrupt policy-making.” These decisions require democratic legitimacy, and they should stay at the democratic level. What they should not do is specify implementation mechanisms.
The architecture layer is professional. Given the goal Congress has articulated, what institutional mechanisms actually achieve it? What accountability structures prevent capture? What feedback loops detect when the system is drifting from its goal? How do we anticipate gaming responses? This is work that requires genuine expertise in institutional design, systems thinking, and failure analysis. It requires the ability to iterate based on outcomes — something legislation cannot do.
The accountability layer reconnects them democratically. Professional architects propose systems. Democratic representatives approve or reject. Senate confirms leadership. Congressional oversight reviews outcomes. Democratic override remains available if architects exceed their mandate. But day-to-day design decisions are insulated from the political cycles that corrupt implementation.
This isn’t theoretical. We already use this model for monetary policy. The Federal Reserve doesn’t ask Congress to vote on interest rate adjustments or bank capital requirements. Congress set the mandate — price stability and maximum employment — and a professional body with democratic oversight implements it. We use the same model for transportation safety through the NTSB, for public health response through the CDC, for infrastructure standards through a range of technical agencies.
The question is why we don’t apply it to governance architecture itself.
The Governance Design Agency
This is what the Governance Design Agency would do.
Not make policy decisions. Not override democratic priorities. Not operate without accountability. The GDA would be constitutionally structured with democratic oversight, Senate confirmation of leadership, and congressional review of outcomes — just as the Fed operates.
What it would do is apply professional institutional design to the architecture questions that democratic process handles badly. Healthcare: design an institutional system that actually achieves universal coverage, with accountability mechanisms, feedback loops, and the ability to iterate. Campaign finance: design structures that remove pay-to-play incentives regardless of who’s in office. Budget process: design a mechanism that literally cannot produce government shutdowns. These are engineering problems. They require engineering solutions.
Consider how the healthcare example would work differently. Congress sets the goal: universal coverage with cost control. The GDA designs the institutional system, begins implementation, and monitors outcomes. Five years in, coverage has improved but cost control is lagging. Congress adjusts the mandate: maintain coverage gains, prioritize cost control. The GDA iterates the design without rebuilding the entire system from scratch.
Under the current model, that iteration requires new legislation — which means another decade of partisan fighting, industry lobbying, compromise that weakens the mechanism, and amateur engineering that creates new gaps. The structural problem persists because the system can’t learn.
The Standard Objection
This sounds like technocracy. It’s the opposite.
Technocracy means experts making value decisions that should belong to democratic processes. The GDA model does the reverse: it preserves democratic authority over value decisions (what goals to pursue, what trade-offs to accept) while applying professional expertise to technical decisions (how to build institutional systems that achieve those goals).
Democracy is too valuable to waste on bridge specifications. We need it for the decisions that actually require it: what kind of society we want, how to balance competing interests, what we owe each other. When we exhaust democratic energy on mechanism design — on thirty-hour work week thresholds and individual mandate penalty calculations — we’re spending legitimacy on engineering work and doing the engineering badly.
Better politicians don’t fix this. The tools available to politicians — legislation through democratic process — produce the failure pattern regardless of politician quality. We need different tools, applied by people with different expertise, with democratic oversight that keeps them accountable to the goals that legitimately belong to democratic decision-making.
The Choice
We’ve been running this experiment for decades. Healthcare, financial regulation, education, environment, infrastructure — the pattern holds across every domain. Democratic compromise produces half-measures. Amateur engineering leaves gaps. Mechanisms get locked into legislation. Implementation through broken governance corrupts intent. Both sides end up frustrated. The structural problem persists.
This is predictable. Not a bug in democracy — a consequence of asking democracy to do architecture’s job.
The solution isn’t less democracy. It’s properly structured democracy: clear about what democratic process should decide, and equipped with professional architecture to make democratic goals actually achievable.
Democracy sets the goals. Professional design builds the systems. Accountability keeps both aligned.
That’s the Governance Design Agency. That’s what I would build. Not tentatively, not as one option among many — because the alternative is choosing the failure pattern we’ve already lived through, again, across every policy domain, for another fifty years.
We can do better. The architecture exists. We’re choosing not to build it.
Share the loading symbol. Demand professional governance architecture. Let’s build this.