Resources
/
Operations
Operations
November 11, 2024

The Hidden Pattern Behind Every Crypto Accident

Most people think safety is about making things that don't break. But after years of building rockets, I learned something different: Safety isn't about components. It's about relationships.
John Rising

Most people get safety wrong. They think it's about making things that don't break. But that's like saying driving is about having a car that runs. It's true, but it misses something deeper.

Safety isn't about components. It's about relationships.

This seems obvious once you notice it, but it took me years of building rockets to see it clearly. When something went wrong, we'd obsess over part reliability and failure modes. But the really dangerous problems weren't about parts failing. They were about parts working perfectly but interacting badly.

Consider what's actually happening when you drive a car. You have a driver with certain beliefs about how the car works. You have controls that let the driver affect the car's behavior. And you have feedback that tells the driver what's happening. Safety emerges from how these pieces work together.

Engineers call this a control system. The driver is the controller, using a mental model to decide what to do. They issue commands through the steering and pedals. The car responds and provides feedback through position, speed, and sound. The driver uses this feedback to update their model and adjust their actions.

Accidents can happen because things break, but that isn’t the only way. Accidents also happen when there's a mismatch between what the controller thinks and reality: When controls are confusing, when feedback is delayed, when mental models are wrong.

Safety isn't a property of individual parts. It's a property of the whole system. A perfectly reliable car with confusing controls is unsafe; so is a responsive vehicle operated on the wrong side of the road.

Instead of asking "Will this component fail?", we should ask "How do these components interact?" Instead of focusing on preventing failures, we should focus on creating the right relationships between parts.

The relationship between feedback and actions are feedback loops. When these loops work well, the system naturally stays safe. When they break down—through delayed signals, unclear feedback, or incorrect assumptions—accidents happen.

Now consider managing operations on a blockchain.

The structure is identical. You have users with mental models of what's happening. They issue commands by signing transactions. The blockchain provides feedback through confirmations and balances. But traditional crypto wallets create terrible system dynamics:

  • Unclear feedback (Did that transaction work? What will this contract do?)
  • Delayed signals (Wait for confirmation... keep waiting...)
  • Mismatched mental models (What exactly happens when I sign?)
  • Poor control granularity (All or nothing access)

The result is a system that's technically secure but pragmatically unsafe. The components won't fail, but the relationships between them are so poor that mistakes become inevitable.

This is why most crypto companies operate in constant fear. Not because their tools are unreliable, but because the system dynamics make safe operation unnecessarily hard.

Smart accounts fix this by focusing on the relationships that matter. Instead of watching block explorers, operators get clear signals about transaction status and risk exposure. Instead of all-or-nothing access, permissions match exactly what each person needs. Instead of cryptic technical interactions, operations map to familiar business concepts. Instead of waiting for confirmations across multiple systems, the state of operations is immediately clear.

The result isn't just technically secure—it's pragmatically safe. The relationships between components naturally guide operations toward desired behavior rather than fighting against it.

Some might say this is an abstract way to think about crypto operations. But the most practical insights often come from seeing old problems in new ways. By understanding safety as a systems property rather than a component property, we can build tools that don't just prevent failures, but actively guide us toward success.

The companies that get this right will stop treating crypto operations as a technical problem to solve. They'll treat it as a systems problem to shape. The tools exist. The missing piece is understanding how to arrange them into relationships that naturally promote safe operation.

After all, safety isn't about preventing things from going wrong. It's about making it natural for things to go right.