The silence between the digits holds the truth.
I first noticed it during a routine audit of a DeFi lending protocol in 2021. The smart contract was flawless by any standard—audited by three firms, formal verification passed, TVL north of $500 million. Yet when I simulated user interactions with varying inputs, the outcomes diverged wildly. The same function, the same parameters, but different slippage tolerances, different gas limits, different order types—and suddenly the protocol behaved as if it were a different machine. The code was deterministic, but the user's framing of the transaction was not.
That moment crystallized something I had been circling for years: the invisible labor of interaction design. In the world of large language models, we call it prompt engineering. In blockchain, we call it transaction crafting, gas optimization, or just “knowing how to talk to the chain.” But the underlying dynamic is identical. The system is trained—or coded—to respond to a wide range of inputs, but the quality of the output depends on the user’s ability to translate their intent into the language the system understands.
We built castles on the tidal data of sentiment.
Context: The Alignment Problem in Two Worlds
The alignment problem in AI is well-documented: how do you ensure a superintelligent system’s goals align with human values? In blockchain, the alignment problem is less dramatic but equally pervasive. Smart contracts are deterministic, but their behavior is shaped by user inputs, economic incentives, and governance mechanisms. A DeFi protocol is not a monolithic entity; it is a constellation of possible states, each triggered by a specific combination of user actions. The protocol’s “alignment” is not just a matter of code correctness, but of how users navigate the space of possibilities.
Consider the parallel with RLHF. In LLMs, the training process—RLHF, reward modeling, instruction fine-tuning—shapes the model’s behavior at a global level. The model learns to prefer certain kinds of answers: detailed, structured, deferential, safe. But the same model, given different prompts, can produce radically different outputs. The prompt is a user-side alignment mechanism, a way to steer the model toward a specific region of its behavior space. The model’s latent capabilities are fixed, but the prompt determines which capabilities are activated.
Blockchain protocols operate similarly. The smart contract’s code is the training. The reward mechanism is the reward model. The user’s transaction parameters—gas price, slippage tolerance, deadline, function arguments—are the prompt. The protocol’s response is deterministic given the inputs, but the user’s choices determine whether the outcome is optimal, catastrophic, or something in between. The invisible labor of prompt design has a direct analogue in blockchain: the labor of transaction design.
Core: The Hidden Architecture of User-Side Alignment
Let me ground this with a technical example from my own experience. In 2023, I was analyzing a automated market maker (AMM) on Ethereum. The core logic was constant product formula: x*y=k. Simple. But the user’s experience varied dramatically based on the prompt they crafted—the transaction parameters. A user who submitted a swap with a 0.5% slippage tolerance and a 5-minute deadline was effectively writing a prompt that said: “Execute this trade only if the price moves less than 0.5% and within 5 minutes.” Another user, with 2% slippage and a 30-minute deadline, wrote a different prompt: “Execute this trade even if the price moves significantly, and wait longer.” The same AMM, same pool, same trade size—but the outcomes were different. The first user might get a near-perfect execution; the second might suffer from adverse price movement or sandwich attacks.
This is not a bug. It is a feature of the protocol’s design. The AMM allows users to specify their tolerance for slippage and time. But the onus is on the user to craft the right prompt. The protocol does not know the user’s real intent. It only knows the numerical parameters. The user must translate their fuzzy mental model—“I want to swap ETH for USDC without getting rekt”—into a precise set of constraints. This translation is the invisible labor.
Now consider the RLHF analogy. The reward model in LLM training is designed to capture human preferences. But the reward model is imperfect. It might prefer overly long answers, or it might penalize honesty. The prompt is a way to compensate for those imperfections. Similarly, a blockchain protocol’s economic incentives are the reward model. The protocol “prefers” certain user behaviors—e.g., providing liquidity, avoiding arbitrage. But the user’s prompt—their transaction parameters—can adjust for the protocol’s blind spots. A user who sets a low slippage tolerance is effectively saying: “I know the protocol’s reward model doesn’t protect me from MEV, so I will add my own guardrails.”
This parallel becomes even clearer when we look at the evolution of both fields. In LLMs, the early days were characterized by naive prompting: “Tell me about X.” Users expected the model to read their minds. The results were often generic or off-target. Over time, best practices emerged: role-playing, chain-of-thought, constraint specification, output formatting. The community invented a new literacy—prompt design—that sits between the user’s intent and the model’s response.
In blockchain, a similar evolution is underway. The early days of DeFi were marked by naive transactions: users set default slippage, ignored gas prices, and trusted the protocol. The results were often catastrophic: hacks, liquidations, sandwich attacks. Over time, best practices emerged: setting explicit slippage limits, using flashbots for private transactions, simulating trades before execution, using aggregators that optimize across multiple prompts. The community invented a new literacy—transaction design—that sits between the user’s intent and the protocol’s response.
But there is a crucial difference. In LLMs, the prompt is visible and editable. In blockchain, the transaction parameters are often hidden behind user interfaces. Most users interact with a DeFi frontend that sets default parameters. The frontend is the interface that translates user intent into transaction prompts. The invisible labor is thus shifted from the user to the frontend designer. But the frontend’s defaults are themselves a form of alignment—they reflect the designer’s assumptions about what users want. When a frontend sets a default slippage of 0.5%, it is effectively writing a prompt on behalf of the user. The user may not even know they are using a prompt.
This is where the alignment problem gets interesting. Who controls the prompt? The user, the frontend, or the protocol? In the early days of DeFi, the frontend was often the protocol itself. Users interacted with Uniswap’s official interface, which had reasonable defaults. But as the ecosystem grew, third-party interfaces emerged, each with different defaults. Some interfaces set high slippage to ensure execution, exposing users to MEV. Others set low slippage, leading to failed transactions. The prompt became a battleground for user attention and safety.
Liquidity is a ghost that haunts the ledger.
Contrarian Angle: The Myth of Decoupling
A common narrative in crypto is that users are sovereign—they control their own keys, they choose their own transactions. But this narrative ignores the structural dependency on prompts. The user may control the keys, but they do not control the internal logic of the protocol. They are forced to interact with the protocol on its terms. The prompt is the only point of leverage. But the prompt is constrained by the protocol’s design. The user cannot change the reward function. They can only tune their inputs.
This is the contrarian thesis: the invisible labor of prompt design is not a sign of empowerment, but of incomplete alignment. The protocol’s training (the smart contract) is fixed. The user’s alignment (the prompt) is a stopgap. The system is not truly aligned until the user’s intent can be expressed without requiring expert-level prompt engineering. In LLMs, we are moving toward instruction-tuned models that can handle vaguer prompts. In blockchain, we are moving toward intent-based protocols that abstract away the parameters. But these solutions are still nascent.
Consider the rise of account abstraction and smart accounts. These are attempts to shift the invisible labor from the user to the protocol or the wallet. Instead of the user crafting a raw transaction prompt, the wallet interprets the user’s intent and generates the optimal transaction parameters. This is analogous to the shift from raw prompting to using a prompt engineering framework. But just as prompt engineering frameworks are not perfect, account abstraction is not a panacea. It introduces new layers of trust and complexity.
Moreover, the parallel between LLM alignment and blockchain alignment reveals a deeper truth: both fields are struggling with the same fundamental problem. How do you design a system that is both flexible and safe? Flexibility means the user can express a wide range of intents. Safety means the system does not allow harmful or unintended outcomes. The prompt is the interface between flexibility and safety. It is the user’s lever to navigate the trade-off. But the system’s designers must decide how much leverage to give the user. Too much leverage, and the system becomes unsafe. Too little, and the system becomes rigid.
Takeaway: The Future of Invisible Labor
So where does this leave us? The invisible labor of prompt design—whether in LLMs or blockchain—is not going away anytime soon. It is a fundamental consequence of building systems that are both powerful and generic. The more powerful the system, the more the user must specify their intent. The more generic the system, the more the user must compensate for its lack of context.
But there is a path forward. The next generation of blockchain protocols will likely incorporate more sophisticated alignment mechanisms at the protocol level. Cross-chain messaging protocols, for example, are already experimenting with “intent-based” architectures where the user simply states what they want, and the protocol figures out how to achieve it. Similarly, LLMs are moving toward tool-use and multi-step reasoning, where the model can ask clarifying questions instead of relying on perfect prompts.
Yet even these advances will not eliminate the invisible labor. They will simply shift it. The user will still need to learn how to express their intent in a way the system can parse. The difference is that the system will become more forgiving. But forgiveness is not the same as alignment. Alignment is about the system understanding the user’s true values, not just their explicit instructions.
The archive remembers what the algorithm forgets.
As I reflect on the years of auditing smart contracts and analyzing LLM behavior, I am struck by a common theme: the human element. The code is deterministic. The model is trained. But the interaction is shaped by human judgment, human error, and human creativity. The invisible labor is not a bug to be fixed; it is a feature of the human-machine relationship. It is the space where we, as users, exert our agency. It is the silence between the digits where the truth resides.
Perhaps the goal is not to eliminate that labor, but to make it visible. To recognize that every transaction, every prompt, is an act of translation. And to design systems that honor that translation, rather than hiding it behind defaults and abstractions.
After all, we built castles on the tidal data of sentiment. The least we can do is acknowledge the foundation.
Structure cannot contain the chaos of human hope.