“Code is law” is the principle that smart contracts should execute exactly as written, without external override. On Ethereum Classic, this is not a slogan. It is an operational commitment: the network will not intervene in contract execution, regardless of the outcome.
What the Principle Means
When a user deploys a smart contract to a blockchain, they publish a set of rules that the network enforces automatically. Every node validates every transaction against the contract's bytecode. The result is deterministic: given the same input and state, every node produces the same output.
“Code is law” means that this deterministic execution is the final authority. No committee, foundation, or majority vote can alter the result after the fact. The contract's code defines what is permitted, and the blockchain enforces those rules without exception.
Why Immutability Matters
A blockchain's value proposition rests on a specific guarantee: once a transaction is confirmed and buried under subsequent blocks, it cannot be reversed or altered. This guarantee is what distinguishes a blockchain from a conventional database.
If a blockchain's history can be rewritten by social consensus — even with good intentions — then the guarantee is conditional. Users must trust that the social layer will not intervene in their transactions. At that point, the system offers no meaningful advantage over a traditional institution that processes transactions subject to human judgment.
Immutability removes the need for trust. Users do not need to evaluate the intentions, competence, or politics of any governing body. They only need to read the contract's code.
The Crypto-Decentralist Position
The Crypto-Decentralist Manifesto, published by the Ethereum Classic community, articulates the core argument: blockchains are useful specifically because they are immutable and censorship-resistant. These properties are not incidental features that can be traded away when convenient. They are the reason the technology exists.
The manifesto identifies three properties that a blockchain must maintain to be genuinely decentralized:
- Immutability: No entity can alter confirmed transactions.
- Fungibility: All units of the native currency are interchangeable, with no blacklisting or differential treatment.
- Neutrality: The protocol does not discriminate between users, applications, or transactions.
If any of these properties can be overridden by social consensus, the blockchain is not decentralized in any meaningful sense. It is a database with extra steps.
Practical Implications
On Ethereum Classic, “code is law” has concrete operational consequences:
- No bailouts: If a contract is exploited, the chain does not roll back to return funds. The exploit is part of the permanent record.
- No rollbacks: Confirmed transactions are final, regardless of their size or the parties involved.
- No privileged accounts: No address has special status. There is no admin key that can freeze assets or modify contract state outside of the contract's own rules.
- No irregular state changes: Protocol upgrades modify the rules going forward. They do not retroactively alter past state.
Why This Matters for Applications
Decentralized finance, supply chain verification, identity systems, and any application that relies on trustless execution needs a predictable environment. Developers need assurance that the rules their contracts enforce today will still be enforced tomorrow.
Users need assurance that depositing assets into a contract means the contract's rules — and only those rules — govern what happens to those assets. If a third party can override contract execution, the “decentralized” label is misleading.
Addressing the Counterargument
The most common objection is: “What about bugs? What if a contract has a vulnerability?”
The answer is that bugs are a problem of contract quality, not a problem of chain policy. The correct response to buggy contracts is better auditing, formal verification, insurance mechanisms, and careful development practices — not chain-level rollbacks. Once a blockchain establishes that history can be rewritten to fix mistakes, there is no principled boundary for when that power should or should not be used.
Ethereum Classic's position is that the cost of maintaining immutability — including the cost of contract bugs — is lower than the cost of abandoning it.