Code Against the Machine
How Cypherpunks, Technoanarchists, and Ethereum Build Post-State Futures
“Privacy is necessary for an open society in the electronic age.” — Eric Hughes
GM
A friend once told me to buy a better graphics card to run a program that "created monetary value." I wasn’t new to distributed computing (think Seti@home), but this was different: 2011 Bitcoin mining. I tinkered, sold BTC on shady IRC chats via PayPal for $10–$20 a coin, and cashed out my last coins in 2013 when BTC was at ~$100, at my fiancée’s suggestion. "It’s a tidy profit," she said. We bought coal for the winter. First I warmed my room with GPU heat. Second, with that coal. Third, I warmed up to the idea of a decentralized future. No turning back.
In 2017, I mined again—this time Ethereum. Programmable money blew my mind. I sold for profit, but the real win was the rabbit hole.
Fast-forward to 2019: work handed me a crypto wallet project. Turns out, I was the only one who could decode the cryptic "crypto thingy" (yes, I still use that term unironically—it’s not a bug, it’s a feature). I dove into cryptography, consensus mechanisms, and blockchain fundamentals. Hooked again.
I joined EthBelgrade as a speaker in 2023 and became a volunteer, helping wherever the chaos needed me. Today, I’m here to connect a few dots—and dig into why I’m still here, knee-deep in this weird, wild blockchain world.
Cypherpunks – Rebels with a Cause
“A specter is haunting the modern world—the specter of crypto anarchy.”
— Timothy C. May
Long before I read a manifesto, I was already living the cypherpunk ethos. I encrypted emails. I encrypted my phone before it was the default. Experimented with custom ROMs. Guarded keys with YubiKeys—no clue a movement existed. Privacy wasn’t a buzzword; it was muscle memory.
But what even is privacy?
It’s the right to selectively share—to control what parts of your identity you reveal, and to whom. Autonomy. Boundaries. The digital equivalent of closing a door.
Then I discovered them:
- Tim May, who skipped coding to write The Crypto Anarchist Manifesto—arguing math could replace institutions.
- Eric Hughes, who defined digital privacy in A Cypherpunk’s Manifesto and launched the mailing list that organized a revolution.
- Phil Zimmermann, who put strong crypto in everyone’s hands via PGP, because “privacy is a right.”
Their work isn’t history—it’s tooling.
- ProtonMail’s PGP guts.
- GrapheneOS on my phone.
- YubiKeys guarding my keys (yes, still).
Cypherpunks don’t die. They compile.
Technoanarchists – Architects of the Ungovernable
“I come from Cyberspace, the new home of Mind.”
— John Perry Barlow
Anarchy isn’t lawlessness—it’s a system where we write the rules. Technology doesn’t just enable this; it demands it. Decentralization is the techno-anarchist’s lifeblood: spreading responsibility across nodes, resisting co-option by governments, and replacing hierarchies with voluntary coordination.
Programmable blockchains? They’re not just infrastructure. They’re immutable constitutions—governance rules etched in code, enforced by math, not intermediaries. Trust isn’t granted; it’s provable.
But this isn’t about abstract protocols. It’s a hands-on rebellion:
Paying with cash to opt out of surveillance. End-to-end encryption to reclaim privacy. Sliding my phone camera cover—because my hardware, my rules.
When I worked on a client’s hardware wallet—I realized securing keys isn’t just engineering. It’s a political manifesto. Every line of code, every soldered chip says: This is mine. This is mine. This is mine.
The future isn’t built by institutions. It’s forged by people who code, solder, and vote—with their own hands.
Bitcoin – The Spark, Not the Fire
“What is needed is an electronic payment system based on cryptographic proof instead of trust.”
— Satoshi Nakamoto
Bitcoin taught me ownership isn’t a privilege—it’s a right. With just a seed phrase, I held absolute control over my value. It kept my identity private, hid my assets in plain sight, and let me transact without begging for permission. No bank could censor it. No institution could gatekeep it.
But that was all it wanted to be—a base layer for money. Static. Predictable. I left because Bitcoin’s simplicity felt limiting—I craved novelty, experimentation, and the thrill of building beyond money.
Ethereum was the spark. Suddenly, code could enforce trust. Smart contracts could replace intermediaries. Yes, most still use it for “money 2.0”—but for someone who speaks its language, the potential is limitless: DeFi, DAOs, NFTs, privacy tools… the list grows daily.
Selling my BTC still stings when I see its price today. But the real ROI wasn’t in the coins—it was in the decentralized values I had absorbed along the way: self-sovereignty, resistance to control, and the belief that systems should serve people, not the other way around.
Bitcoin gave me freedom. Ethereum gave me a canvas.
Ethereum – Where Ideals Become Tools
“Ethereum is a decentralized platform that runs smart contracts...”
— Ethereum Foundation documentation
And while Bitcoin lit the match. Ethereum built the forge—a lab where ideology meets code. While Bitcoin stayed a spark, a perfect, unchanging base layer, Ethereum became the place to ask the hard question: Can decentralized infrastructure replace institutions? Spoiler: Not yet, but we’re building.
The techno-anarchists dreamed of a “world computer,” a shared machine where anyone could deploy trustless apps. Ethereum delivered—but with limits. Scalability bottlenecks choked throughput, driving fees so high they became gatekeepers in disguise. Access had its own flaw: “Pay-to-play” wasn’t freedom. You needed ETH just to use ETH. Ethereum’s core wasn’t broken, but it was unfinished—a monolith straining under its own ambition.
So the system broke itself apart. The endgame? Specialized layers. Ethereum’s core became the settlement layer, anchoring security while Layer 2s—rollups—took the strain of transactions. Modular upgrades turned scarcity into abundance, infinite scalability without sacrificing the decentralized bedrock.
But access wasn’t the only flaw. The account model was a glass house—every balance, transaction, and pattern visible to all. That’s where Zero-Knowledge Proofs stepped in. ZKPs let you prove a computation is valid without revealing its inputs. ZK-EVMs are already here, turning Ethereum’s transparency into selective opacity. Soon, you’ll validate ownership without exposing your holdings, execute trades without leaking strategies.
And then there was the pay-to-win problem. Ethereum’s latest upgrade fixed it: EIP-4337 lets any token pay gas fees. No ETH? No problem. Someone else can sponsor your actions, turning “pay-to-play” into “pay-with-anything.”
Ethereum isn’t a product. It’s a movement—a living system rewriting its own code. Sharding, ZKPs, state rent—each upgrade a step toward a future where openness, scalability, and privacy aren’t trade-offs but defaults. The decentralized world computer isn’t finished. It’s alive. And like fire, it only grows when we all add fuel.
Post-State Futures – A Values Audit
“A DAO is an entity that lives on the Internet and exists autonomously”
— Vitalik Buterin
DAOs aren’t just governance tools—they’re the techno-anarchist lab where social contracts get compiled into smart contracts. The dream? Communities govern themselves, bypassing hierarchies. The reality? Most are still prototypes, crashing into edge cases like legal systems, incentive design, and human ambition.
Governments don’t know what to do with DAOs, so they shoehorn them into 20th-century legal buckets: LLCs, corporations, trusts. Suddenly, experiments in self-governance become paperwork compliance. The revolution gets a CFO.
Unbalanced tokenomics? Power concentrates. A few whales = de facto board of directors. DAOs meant to democratize control often replicate the very systems they’re trying to replace.
Even when DAOs hold votes, turnout is often shockingly low. Why?
- Apathy: Token holders prioritize price over protocol.
- Complexity: Governance proposals are dense, technical, or poorly communicated.
- Incentive gaps: Voting doesn’t always reward participation—or punish apathy.
Low turnout isn’t just a bug; it’s a systemic risk. A tiny faction can dictate outcomes, turning “decentralized” decisions into plutocratic referendums.
Here’s the hack: Forking is the immune system of decentralized governance. If a DAO goes off the rails, communities can split, take the code, and try again. No court rulings. No board votes. Just a git clone and a manifesto.
I voted on AIP-1. 76% said no. The decision was already made. The vote? A rubber stamp for a centralized team’s roadmap. No grassroots movement. No open debate. Just a token holder poll to legitimize a decision that has already been made.
Was it a failure? Depends on your lens. The DAO didn’t die. It learned: decentralization isn’t a checkbox—it’s a process.
DAOs aren’t the endgame. They’re the alpha software for self-sovereign communities. They’ll break. They’ll get rekt by greed, inertia, or regulation. But as long as forking exists, the techno-anarchist dream stays alive: Code as governance. Power to the people. Always beta.
The Tension – Idealism vs. Reality
“Security is always a trade-off. ... I call them ‘dual-use’ technologies.”
— Bruce Schneier
Now that crypto’s reached a wider audience, many see only “number go up”—not the ideas beneath blockchains. Big players with deep pockets could exploit this. Imagine a threat like:
“I see you have a nice blockchain here. It’d be a shame if its value crashed tomorrow.”
Suddenly, decentralization isn’t just about resisting governments—it’s about resisting economic coercion from entities that treat protocols like poker chips.
Bruce Schneier once said: security always involves trade-offs. VPNs, Tor, end-to-end encryption—these tools protect me, sure. But they also protect criminals. That doesn’t mean we surrender privacy. It means we choose our battles. Using privacy tech doesn’t imply guilt. It implies agency.
We make these trade-offs daily. Last weekend, I paid cash for coffee at 7 in the morning. Got 20 small bills back instead of 4 large ones—register didn't have big notes. Swiping a card would’ve been easier. Faster. Cleaner. But it would’ve created a digital breadcrumb. Every choice chips away at anonymity.
Even building this deck was a trade-off. Yes, it was written with an AI assistant. Not because I’m lazy—I could’ve rambled for days without one. But for brevity and clarity? A must. The model I used remembers me—it learned my voice, gave sharper answers. I could’ve used a “privacy-first” AI that forgets everything, but it would’ve been slower, blander. Less… me.
I’m only human. I fumble privacy—sometimes I prioritize convenience. But I keep my “world settings” as low as possible: minimal tracking, no biometrics, no centralized logins.
Here’s the confession: I’m not building the tools I wish existed. I’ve dreamed of them for years—privacy-first protocols, decentralized infrastructure, systems that protect users by default. But I’ve chosen a different path: family, career obligations, and the inertia of “good enough” solutions.
I’ve spent my energy on client projects, on code that pays the bills—not on revolutionizing privacy. And now? Time is a luxury I can’t afford.
But here’s the thing: It’s not too late for you.
I’m asking you—the builders—to take what I’ve stumbled through and run further. To plant trees under whose shade you may never sit. Because the post-state future isn’t about any one person. It’s about all of us writing code, forking protocols, and making trade-offs that tip the balance toward freedom.
Because…
Fork the future
Cypherpunks write code.
— Eric Hughes
Back in the day, when my crypto story began, I never imagined I’d stand here—asking you to build the future. But here we are.
Build like the future depends on you. Because it does.
Ask yourself:
Do your tools expand human agency—or replicate old hierarchies?
Do they guard privacy by default—or demand trust in centralized systems?
Act now. Install one privacy-protecting app tonight. Scan this QR code from my recommendations—tools I’ve vetted, tested, and use daily.
Start small. Take one step. Then build on it.
And never give privacy away easily. Every time you trade it for convenience, ask: Is this price worth it?
The post-state future isn’t a revolution—it’s a thousand incremental choices. You’re not just coding features. You’re writing freedoms.
Because in the end, the future belongs to those who code it.