IF I RECORD A MOUSE CLICK ON A VAR ENVIRONMENT, I get a skill. If the button moves by 3 pixels, the skill fails. That is not automation. That is a brittle deterministic trace of a single execution path dressed up as intelligence. Anthropic’s latest feature – Record a Skill – and OpenAI’s identical Codex function represent the same failure mode: behavioral cloning without the rigor of a verifiable execution layer. As a Smart Contract Architect who has spent years auditing on-chain logic, I see an abstraction leak that the market is ignoring.
Reversing the stack to find the original intent. The original intent was to let anyone create reusable workflows without writing code. The surface-level promise is seductive: ‘Show Claude once, and it remembers forever.’ But dive into the implementation, and the cracks appear. The skill is not a compiled program; it is a multi-modal prompt – a mix of natural language instructions, UI element selectors (often fragile XPaths or coordinate heuristics), and embedded scripts (usually Python or shell commands). The model at runtime interprets this prompt, takes a fresh screenshot, and decides the next action. Every execution is a new inference call to a centralized API. The failure mode is non-deterministic by design.
Truth is not consensus; truth is verifiable code. In blockchain automation – think Gelato, Chainlink Keepers, or even a simple Timelock contract – every trigger and action is deterministic, auditable, and immutable on-chain. If a keeper bot misbehaves, the transaction is reverted, and the code is there to be blamed. Record a Skill offers none of that. The execution outcome depends on the model’s weight at inference time, which can change with a model update. The skill’s internal representation is opaque; you cannot open a debugger and step through the logic. For an industry built on transparent smart contracts, this is a step backward.
Context: The Market Race to the Bottom of Abstraction. Both Anthropic and OpenAI are rushing to capture the ‘AI agent for the office’ market. They see a goldmine in replacing manual RPA (Robotic Process Automation) scripts with a simple demo. The logic is sound: lower the barrier, grow the user base, lock them into subscriptions. But they are competing on features, not on reliability. The true test is not whether you can record a skill, but whether that skill executes correctly when the target application has updated, or when the internet connection drops, or when the model hallucinates a click coordinate. Based on my experience auditing 0x protocol in 2017, I learned that any system that relies on a single point of failure – here, the LLM API – is a threat vector waiting to be exploited.
Core: The Technical Architecture of a Fragile Stack. Let’s trace the execution path of a recorded skill step by step.
- Recording phase: User performs a task – clicks, types, speaks. The client captures: screen frames, timestamps, key events, voice audio. This data is streamed to Anthropic’s server. The server uses a multi-modal model (presumably Claude 3.5 Sonnet or Opus) to parse the demonstration and generates a ‘Skill’ – essentially a JSON with a structured prompt. This skill is stored on Anthropic’s cloud.
- Execution phase: User triggers the skill. The agent captures the current screen, sends it along with the skill prompt to the API. The model outputs an action (e.g., ‘move mouse to (x,y)’, ‘click’). This is repeated until the task ends.
- Failure modes: If the UI changes (button renamed, button moved, popup blocking), the model may misinterpret. If the network is slow, the action delay causes race conditions. If the model is rate-limited, the skill hangs. If the skill includes a password prompt, that prompt is now on Anthropic’s server.
Compare to on-chain automation: I can deploy a smart contract that calls approve on a DEX at a specific block height. That call is deterministic, gas-measured, and reversible only by another transaction. No black box. No server dependency.
The recorded skill is essentially a centralized oracle for your desktop. It observes, it decides, it acts – but all under the control of a single entity. In DeFi, we call that an oracle manipulation risk. Here, the manipulation is done by an AI model that you cannot audit.
Abstraction layers hide complexity, but not error. The beauty of a smart contract is that even if the abstraction layer is complex (Solidity compiler, EVM), the final bytecode is verifiable. For Record a Skill, the abstraction is the model itself. You cannot decompile the skill to verify its logic. You cannot replay it without calling the API. You cannot trust it without trusting Anthropic. This is a centralization vector that the market is ignoring.
Contrarian: The Real Risk is Not Privacy – It’s Vendor Lock-In. Yes, privacy is a concern. Recording every click and key sends your workflow DNA to a third party. But the bigger risk is dependency. Once you have a library of a hundred skills handling your daily operations, you cannot migrate to another platform. The skills are not portable; they are tied to Claude’s API and its specific model behavior. If Anthropic changes its pricing, shuts down the feature, or simply updates the model to break your skills, you are stuck. This is a classic platform risk, amplified by the fact that the workflows are not code – they are opaque black boxes. In contrast, a Gelato keeper written in Solidity can be copied to any EVM chain or run locally. The code is your asset, not a subscription.
Furthermore, the feature lacks a sandbox. Traditional RPA tools at least run locally. Record a Skill sends everything to the cloud. For enterprise users, this is a non-starter. Financial institutions, healthcare, and government require on-premise execution and data residency. Recording a skill that moves customer data from a CRM to an email tool means that data passes through Anthropic’s servers. The terms of service may allow them to use that data for training – a hidden cost. I have seen this pattern before in the NFT metadata debacle where projects relied on centralized IPFS nodes. The same fallacy applies here: “It works for me today, so it must be decentralized.” No, it’s just not yet broken.
Takeaway: The Future of Automation is Composable, Verifiable, and Permissionless. Until Record a Skill outputs a deterministic artifact – a script that can be locally executed or on a decentralized runtime – it remains a centralized garden with a pretty gate. The market will eventually realize that reliability and portability matter more than a one-click demo. I am watching for a project that bridges this gap: record your demo, compile it into a formal verification-friendly format, and deploy it on a decentralized execution layer. Until then, I will keep my automation in solidity and scripts.
Truth is not consensus; truth is verifiable code. The code of a recorded skill is invisible. That is not an abstraction – it is a veil.