Part 2 of 3: What Crypto Governance Actually Is

For seven years, Bitcoin had run without governance. Decisions happened through informal coordination, and the network functioned smoothly.

Then, in 2015, Bitcoin hit capacity. Blocks filled up. Fees spiked. Transactions slowed.

The community needed to decide how to move forward. Two visions emerged—and no governance structure existed to resolve them.

Two camps formed around fundamentally different ideas of what Bitcoin should be.

Big blockers saw a straightforward solution to a practical problem: increase the block size to 2MB, 4MB, or 8MB. More space meant more transactions and lower fees. Bitcoin could become a true global payment system—fast, cheap, and usable by everyone.

Their proposals included Bitcoin XT, Bitcoin Classic, and Bitcoin Unlimited. Their supporters included miners, exchanges like Coinbase, and businesses that wanted Bitcoin to scale for everyday use.

Small blockers saw the same problem through a different lens. Bigger blocks meant more data, which made running a node more expensive—requiring more storage, bandwidth, and better hardware. If only wealthy institutions could afford to validate the network, Bitcoin would centralize, becoming no different from the system it was designed to replace.

Their answer: keep blocks small, implement SegWit (a compression technique), and build Layer 2 solutions like the Lightning Network. Bitcoin should prioritize being a sound money that users can control, not a high-throughput payment network run by data centers.

Their supporters included Bitcoin Core developers, technical users, and those focused on preserving individual sovereignty.

No governance structure existed to resolve this disagreement. No council. No vote. No authority to appeal to. Just a prolonged, brutal debate.

For two years, the fight consumed every space Bitcoin touched.

Forums split into opposing camps—bitcointalk fractured, Reddit's r/bitcoin and r/btc became warring territories. Developer mailing lists turned into battlegrounds. Conferences devolved into shouting matches. Social media exploded with accusations and propaganda. Mining pools coordinated in private calls.

Every conversation became a proxy battle for Bitcoin's future.

May 2017: The New York Agreement

Fifty-eight companies gathered in a Manhattan conference room—miners, exchanges, wallet providers. No Bitcoin Core developers were invited.

They signed an agreement: activate SegWit, then increase the block size to 2MB within six months. They controlled over 80% of Bitcoin's mining power and represented major economic activity. They believed they'd decided Bitcoin's future.

The community rejected it almost immediately.

Users saw it as corporate capture—a handful of companies meeting in secret to override the network's rules. The narrative that emerged was powerful and tapped directly into Bitcoin's founding principles:

"Bitcoin is money where users set the rules—not corporations."

Summer 2017: UASF (User-Activated Soft Fork)

A grassroots movement formed in response. Users began running nodes that signaled support for SegWit—and only SegWit. No block size increase.

The message was clear: We run the nodes. Nodes enforce the rules. We don't need permission from companies or miners.

It was a remarkable moment. Regular users, armed with cheap computers running Bitcoin software, stood up to mining pools and billion-dollar companies.

August 2017: The Split

SegWit activated on Bitcoin. Those who wanted larger blocks forked off to create Bitcoin Cash, which uses 8MB blocks. Bitcoin continued with small blocks, and SegWit was enabled.

Small blockers had won the narrative war.

The cypherpunks believed code would govern. The Block Size War proved otherwise. Code doesn't govern. People do.

Even without formal structure, decisions still occurred—through years of public debate, social pressure, narrative battles, node signaling, and, eventually, exit via forking. Informal governance emerged whether Bitcoin wanted it or not.

It worked. Decisions got made. But it took two years, fractured the community, and revealed that power still concentrated around those who could influence outcomes—developers who understood the code, early adopters with credibility, narrative-shapers on social media and forums, and economic actors with leverage.

The pattern holds: give individuals the ability to influence decisions, and over time, power concentrates. Not because people are corrupt, but because the structure creates the incentives. Even in a system designed to eliminate authority, authority emerged. It just became harder to see—and harder to challenge.

Satoshi had built Bitcoin without governance based on the cypherpunk conviction that any formal structure becomes a target for pressure, capture, and surveillance. No structure meant no target. No centralized decision-making meant no centralized point of failure.

But the Block Size Civil War revealed the cost: eliminating designed governance didn't eliminate power. It just made power informal, harder to see, and harder to challenge. Decisions still required coordination. Influence still mattered. Authority still emerged—just through different channels.

The cypherpunk assumption was simple: no governance equals freedom.

The Block Size Civil War suggested something more complex: no designed governance equals hidden governance.

Bitcoin has shown that you can make decisions without formal structures. But it left open whether that actually preserved the freedom it was designed to protect—or just obscured where power really lived.

While Bitcoin wrestled with scaling, Ethereum faced a different kind of crisis—one that would test not the absence of governance, but the core value that was supposed to make governance unnecessary.

2016. Mittweida, Germany.

Christoph Jentzsch had spent years building Ethereum's infrastructure—the C++ client, obsessive testing, making sure the foundation was solid. In 2015, he and his brother Simon founded Slock.it with an ambitious vision: connect smart locks to the blockchain and create a decentralized sharing economy where people could rent, sell, or share physical objects directly. No Airbnb. No platform middleman. Just code.

To fund it, Christoph needed capital. He built something unprecedented: a decentralized autonomous organization—a venture capital fund run entirely by smart contracts. No board. No executives. No human gatekeepers. Token holders would vote on which projects to fund, and the code would execute decisions automatically.

Pure cypherpunk logic: code as structure, math as authority.

Christoph released the framework as open-source. The Ethereum community saw it and immediately expanded the vision. Why fund just Slock.it? Why not create a fund that could back any Ethereum project?

The DAO launched April 30, 2016. Twenty-eight days later, it had raised $150 million from 11,000 investors—the largest crowdfunding in crypto history. It controlled 14% of all Ether in circulation.

June 17, 2016.

Christoph woke in his mother's house to his phone exploding with messages. The DAO was being drained. Sixty million dollars disappearing in real time—$8 million an hour.

A hacker exploited a flaw in the smart contract—a reentrancy bug. The vulnerability allowed the attacker to repeatedly call the contract's withdrawal function, withdrawing funds each time before the contract could update its records to reflect the funds as gone. Withdraw. Withdraw again. Withdraw again—draining the pool before the system could register what was happening.

The vulnerability wasn't hidden. Developers had identified it. Fixes were in progress, awaiting DAO member approval for implementation. The hacker moved first.

The code did exactly what it was written to do. The problem: what it was written to do wasn't what the developers intended.

For the cypherpunks, immutability was sacred. If code is immutable, no authority can rewrite the rules to benefit themselves. No government can seize funds. No corporation can reverse transactions. No human corruption can touch what's written into the blockchain.

That protection was the entire point.

But the DAO forced a new question: What happens when the code itself is broken?

The Ethereum community had to decide.

Option 1: Let it stand. The hacker exploited the code as written. Immutability means immutability—even when the outcome is catastrophic.

Option 2: Rewrite history. Execute a hard fork. Return the blockchain to a point before the hack. Move DAO funds to a recovery contract. Give the money back.

This would break the promise of immutability.

"Code is Law" supporters argued: If we start deciding which outcomes are "legitimate," we've reintroduced human judgment—the very thing immutability was designed to eliminate.

Pragmatists countered that the code had a catastrophic bug. This feature wasn't working as intended. Fixing broken code isn't betraying immutability—it's correcting a failure.

But the question remained: Who decides what counts as "broken"?

July 20, 2016.

Vitalik Buterin supported the hard fork. He had no formal authority, no official power to force a decision. But his voice carried more weight than anyone else's.

Eighty-five percent of Ether holders voted yes. Ethereum executed the hard fork. The hack was reversed. Funds returned to investors.

Those who disagreed split off to Ethereum Classic—preserving the original chain, hack and all. Their stance: immutability without exceptions. Even when it hurts.

The cypherpunks designed code that is immutable to protect against human corruption. But when the code itself failed, only humans could decide what "failure" meant—and whether to fix it.

Before The DAO, the belief was simple: "Code is Law" eliminates the need for human authority.

After The DAO, the reality became clear: Code can't tell you when it's broken. Only humans can make that call.

Is absolute immutability protection—or does it trap us inside our own mistakes? Self-correction is resilience. Fixing errors is adaptation. Do we want a system where catastrophic bugs can't be fixed?

And if humans can override the code when the stakes are high enough—was it ever truly immutable? Or was immutability always conditional, a principle upheld only until it became too costly to maintain?

Even immutability—the core value meant to eliminate governance—requires human judgment to maintain. Someone has to decide when code is working and when it's broken. Someone has to choose whether to intervene.

That's governance. Whether you call it that or not.

Next: Part 3—What Crypto Governance Actually Is: How decisions really get made, where power concentrates, and the questions that remain unresolved.