‘All men are created equal’: America has lost its values. It’s time to go back to the founding text | Ted Widmer - The Guardian

The Declaration of Independence as Open Source: What Software Engineering Teaches Us About Lost Ideals

When Ted Widmer writes that "America has lost its values" and calls for a return to the founding text, he's diagnosing a problem that every senior engineer has seen before: a system that has drifted so far from its architectural principles that it no longer resembles the original design. In two decades of building distributed systems and observing open-source governance models, I've learned that the Declaration of Independence is, at its core, an architectural document - a specification for a system of self-governance. And like any ambitious system, America has accumulated technical debt, suffered feature creep, and watched its original constraints erode under the weight of scale. The Guardian article by Ted Widmer, "'All men are created equal': America has lost its values. It's time to go back to the founding text", echoes what we in tech call a "return to first principles. " This article explores that parallel - and what the founding text can teach engineers building the future.

The Declaration of Independence contains perhaps the most audacious assertion in political history: that all men are created equal and endowed with unalienable rights. But as any developer knows, a beautiful abstraction in a README rarely survives contact with production. Two hundred and forty-eight years later, we're staring at a system that has accumulated so much cruft - gerrymandering, dark money, regulatory capture, algorithmic disinformation - that the original commit message feels like a cruel joke. Widmer's argument is essentially a code review of a nation: "This function no longer matches its specification. Let's roll back to the last known good state. "

The Founding Text as an API Specification for Governance

When the Second Continental Congress voted for independence on July 4, 1776, they weren't just drafting a press release? They were defining an API - a public contract that specified the rights of every node in the network and the conditions under which governance could be forked. The document's structure is remarkably similar to a modern open-source license: it begins with a preamble declaring intent, lists a series of grievances (bug reports against the existing system), announces a fork from the parent repository and establishes a new governance model based on consent of the governed.

As NPR's coverage of the Second Continental Congress notes, the representatives were acutely aware they were designing a system that would need to scale. They deliberately avoided specifying every detail, opting instead for a framework that could be extended. This is exactly how successful software frameworks work: you define the core abstractions and let the community build on top. The problem arises when downstream consumers forget the original constraints. In production environments, we call this "dependency drift. " In politics, it looks like a Supreme Court that reinterprets "equal protection" in ways that would shock the original authors.

The Technical Debt of Inequality: When the Runtime Breaks the Contract

America's founding text promised a system where equality was a first-class primitive. But like any codebase, the implementation had bugs. Women, enslaved people, and Indigenous populations were excluded from the initial commit. Over centuries, amendments and court rulings have patched some of these issues - the 14th Amendment is arguably the most important PR in American history. Yet the fundamental architecture remains vulnerable to exploitation. The same way a SQL injection attack exploits a system's assumptions about input validation, voter suppression exploits the assumption that "consent of the governed" includes everyone equally.

In a 2023 analysis of democratic erosion, the Varieties of Democracy institute found that the United States has experienced one of the most significant declines in democratic quality of any established democracy over the past decade. The data shows that the gap between the system's stated API - "all men are created equal" - and its runtime behavior has widened to a dangerous degree. Engineers understand this intuitively: when your test coverage drops and your error rates spike, you don't ship new features. You debug the core logic. Widmer's Guardian article is essentially saying: "Americans, your test suite is failing. Go back to the specification and figure out where the regression happened. "

Distributed Systems and the Myth of Centralized Authority

The founders understood something that software architects rediscovered centuries later: centralized systems are fragile. The Declaration's insistence on diffusing power among states, branches. And the people themselves was an early exercise in fault tolerance. Thomas Jefferson's famous line about the tree of liberty being watered with blood was, in modern terms, a statement about system resilience: centralized authority will inevitably fail. And the only way to maintain integrity is to distribute trust.

This maps directly onto blockchain philosophy, decentralized autonomous organizations (DAOs). And the broader movement toward Web3 governance. The founding text anticipates concepts like consensus mechanisms, checksum validation. And the principle that no single node should have veto power over the network. But here's where the parallel gets uncomfortable: just as DAOs have struggled with plutocracy (token-weighted voting concentrating power), America has watched its own governance drift toward oligarchy. A 2014 Princeton study by Gilens and Page found that the preferences of average citizens have "near-zero" impact on policy outcomes, while economic elites and organized interest groups dominate. The founding text's equality primitive has been effectively overridden by a richer, more powerful class of actors.

CRDTs, Conflict-Free Replicated Data Types. And the Mechanics of Social Consent

One of the most elegant ideas in distributed systems is the Conflict-free Replicated Data Type (CRDT) - a data structure that allows multiple nodes to make changes independently and then merge those changes without conflict, provided they follow the right rules. The Declaration of Independence can be read as the ultimate CRDT for governance: it defines the merge strategy for resolving disputes between the governed and their government. When the government makes a change that violates the original constraints (like taxing without representation), the people have the right to "alter or abolish" that change - a hard reset to a known good state.

But CRDTs only work if all nodes agree on the merge strategy. America's crisis is that different parts of the network no longer agree on what the merge strategy should be. One faction sees the founding text as immutable, requiring line-by-line adherence to the original commit. Another faction sees it as a living document that must be refactored for modern conditions. This disagreement about the merge protocol is what produces gridlock, government shutdowns, and the erosion of democratic norms. The founding text provides a specification, but it doesn't include an interpreter. That was always the job of the people. And as Widmer argues, we've stopped doing the reading.

The OAuth of Citizenship: Authentication, Authorization. And the Voting System

Every engineer knows OAuth 2. 0 - the authorization framework that allows users to grant limited access to their resources without sharing credentials. The founding text establishes a similar framework for citizenship: you're authenticated by your personhood, authorized to participate in governance. And your consent is the access token that legitimizes the system. But America's authorization layer has been compromised. Voter ID laws, purges of voter rolls, gerrymandered districts. And the outsized influence of money in politics all act as middleware that intercepts and modifies the consent token before it reaches the execution environment.

The result is a system where the authorization doesn't match the authentication you're a citizen (authenticated), but your vote's weight depends on your zip code, your race, your wealth, and your proximity to a polling place. This is a bug so fundamental it violates the core contract of the founding text. In software terms, we'd classify it as an authorization bypass vulnerability - CVE-1776-0001, if you will. Widmer's call to return to the founding text is essentially a call to patch this vulnerability, to re-add the authorization layer according to the original specification rather than the crufty, permissioned version that has evolved over centuries.

Lindy Effects and Legacy Code: Why Old Systems Still Matter

The Lindy effect posits that the longer something has survived, the longer it's likely to continue surviving. The Declaration of Independence has lasted 248 years - longer than any software system in existence. That alone should make engineers pay attention. Legacy code gets a bad reputation. But the oldest running code in production (like the MUMPS system used by the US Department of Veterans Affairs or COBOL on mainframes) is often the most battle-tested. The founding text has survived wars, depressions, civil unrest, and technological revolutions. It's not legacy - it's stable.

The danger isn't that the code is old. The danger is that we've stopped reading it. In my experience debugging production systems, I've found that 80% of critical bugs trace back to someone not understanding the original specification. America's current crisis - the sense that the system is broken, that values have been lost - is exactly this kind of bug. We've built so many layers of abstraction on top of the founding text that we've forgotten what the core logic does. Widmer's article is a lint warning: "DeclarationCheck: Found 47 violations of the 'equal creation' constraint. Recommend rollback to specification. "

Five Common Questions About the Founding Text and Modern Governance

1. Does the phrase "all men are created equal" apply to technology governance?
   Yes. The principle of equal rights and consent maps directly to how we design systems that affect people's lives - from algorithmic hiring to predictive policing. Every system that treats users unequally without transparent justification is violating this founding constraint.
2. How can software engineers apply the founding text to their daily work?
   Engineers can treat the Declaration as a case study in writing clear specifications, defining constraints up front, and building in mechanisms for consent and accountability. Consider writing a "Declaration of System Principles" before starting your next project.
3. Is the United States today less democratic than in 1776?
   By most metrics - suffrage expansion, civil rights protections, free speech - America is far more democratic. But the gap between the founding ideal and current practice, particularly regarding economic equality and voting access, has widened in recent decades.
4. What would returning to the founding text look like in practice?
   It would mean re-centering governance around consent of the governed - ending gerrymandering, reducing money in politics, ensuring universal voting access, and holding representatives accountable to the actual text of the Constitution and Declaration.
5. Does the founding text need to be updated for the digital age?
   The principles are timeless, but the implementation details - like how consent is verified, how rights are protected against algorithmic harm. And how power is distributed in a networked world - demand new thinking within the original framework.

Refactoring American Governance: A Technical Roadmap

If we treat the United States as a software project in need of refactoring, Widmer's article offers a clear action plan: reread the specification, identify regressions, write better tests. And enforce the original constraints. Concretely, this means restoring the Voting Rights Act (which was weakened in 2013), passing campaign finance reform to reduce the influence of money (Citizens United being a notorious injection of a private interest into the public stack). And ensuring that every citizen's consent token counts equally. It also means building new infrastructure - digital voting systems with verifiable paper trails, open-source election auditing tools and transparent algorithmic governance for the platforms that increasingly mediate our public discourse.

The NPR coverage of the Second Continental Congress reminds us that the founders were pragmatists. They didn't expect perfection - they built a system that could be patched and improved over time. But every patch should be consistent with the original architecture. When Widmer writes that "'All men are created equal': America has lost its values. It's time to go back to the founding text," he's not advocating for nostalgia. And he's advocating for correctnessIn engineering terms, it's the difference between hacking around a bug and fixing it at the source. The founding text is the source. It's time to git checkout the original commit and rebuild from there, and as the Inquirer's coverage of the Declaration's 250th anniversary notes, the document was never meant to gather dust - it was meant to be read, debated. And enacted. The question is whether we have the engineering discipline to do the work,?

What do you think

If you could submit a pull request to the Declaration of Independence to make it more robust for the 21st century, what would you change - and what would you refuse to touch because the original constraint is still correct?

Is the concept of "unalienable rights" compatible with distributed systems that have no central authority to enforce those rights,? Or does it inherently require a sovereign interpreter?

When an engineer says "this system is broken, let's go back to first principles," they usually mean returning to a simpler, more correct design. Does the same logic apply to American governance,? Or is the complexity of modern society too great for a return to 18th-century abstractions?