Sam Blackshear and the Art of Making Bugs Harder to Write

At the beginning of his career, Sam Blackshear did something wonderfully unglamorous. He built tools to find mistakes in other people’s code, ran them on open-source projects, and sent the results to the developers. Sometimes a developer fixed a bug. That, he recalled, was a thrill. Much of the rest was esoteric mathematics, fascinating to him and only occasionally useful to anybody else. If you want a neat origin story for a programming language, there it is: a young researcher delighted that a program had helped someone correct a mistake.

Years later, Blackshear was the chief technology officer of Mysten Labs, the company he helped found, and the creator of Move, a language used to write smart contracts. In August 2026 he announced he was leaving for Anthropic to work on defensive security research. The job changed; the original curiosity survived. Across research labs, a proposed Facebook payments network and the Sui blockchain, he has kept returning to the same practical question: how can a system make dangerous mistakes easier to spot, or harder to write in the first place?

A bug hunter learns to write the rules

Blackshear studied computer science and philosophy at Williams College, then pursued a PhD at the University of Colorado Boulder. His field was programming languages and static analysis: techniques for examining code without relying only on running a few examples. The work suited a person interested in what a program really means, including the surprising things it might do when its author is absent. During his doctoral years, an internship at Facebook gave him a close view of large software systems. He later joined the company, where he became a principal engineer.

He has described the early work with a researcher’s mix of affection and candor. The math was fun. The payoff came when a tool could point to a real bug and a developer chose to fix it. That experience also exposed a limit of bug hunting: if a language makes a certain error easy to express, the next programmer can write it again. A tool can raise the alarm, but language design can change the conditions under which the error appears. The insight followed him into a much stranger neighborhood of software, where a bug might involve a valuable asset rather than a broken screen.

In 2018, he joined Facebook’s Libra effort, later known as Diem. The project needed smart contracts, programs that carry out rules for digital assets. Blackshear’s brief was broad: decide how those contracts should be written. He considered an existing smart-contract language, a general-purpose language, and a new one. Creating another language is no casual choice. Developers need documentation, libraries and colleagues who can help them. A clever syntax without a community is a lonely invention. Yet the existing options, in his view, did not give programmers the right basic tools for ownership and transfer.

The coin that should not come back

His favorite explanation requires almost no computer science. If one person hands another a coin, the first person no longer has it. Ordinary data behaves differently: copy a file and both people can have the same bits. For a digital photograph, this is convenient. For a token that represents money or another scarce asset, an accidental copy can be disastrous. Move uses resource types to make those rules part of the language. A resource cannot simply be duplicated like an ordinary value, and its creation and destruction follow declared rules.

“

If I hand something to you, then you should have it and I shouldn’t have it anymore.

Sam Blackshear on the ownership idea behind Move

This was the turn from searching for errors to preventing a class of them. Move did not promise that every smart contract would be correct. It offered a better starting point: programmers could express digital ownership directly instead of rebuilding it from low-level parts each time. Blackshear and collaborators also worked on verification tools that let developers state properties a program should preserve. A paper he co-authored described the resource model through a conservation principle, close to the everyday intuition that a physical object does not appear twice because someone assigned it to a new name.

The language came out of a team, a point Blackshear has made explicitly. In a public discussion about Move’s “hot potato” pattern, he redirected credit to compiler engineer Todd Nowacki and the language’s ability system. It is a small moment, but revealing: a creator refusing the convenient fiction that every clever corner of a large technical project belongs to one person. The Facebook project did not become the payments network its founders had imagined. Move, however, could travel beyond it.

Five colleagues, one new chain

In 2021, Blackshear co-founded Mysten Labs with four former Meta colleagues: Evan Cheng, Adeniyi Abiodun, George Danezis and Kostas Chalkias. The group brought different specialties: programming languages, compilers, product, distributed systems and cryptography. Abiodun later described the founders as friends who had worked together on Libra and wanted to pursue decentralized infrastructure outside Facebook. Blackshear became CTO, and the company developed Sui, a blockchain whose design put objects at the center of how programs and transactions handle assets.

The distinction is technical but the irritation behind it is familiar. In the earlier account-based version of Move, a programmer often had to fetch assets from accounts, do the interesting work, and put everything away again. Blackshear called this bookkeeping. In Sui, the runtime can deliver the relevant objects directly to the program. A transaction declares which objects it will use. That lets the system see, before running two transactions, whether they touch separate things and may be processed in parallel. It also frees the developer to spend more time on the intended action and less on retrieving and replacing the pieces.

Blackshear’s explanations rarely stay abstract for long. To describe programmable transaction blocks, he offered a food court and a buffet. At the food court, each purchase means another payment; at the buffet, one visit can include several choices. In Sui, a developer can compose several actions inside one transaction, with outputs from one action becoming inputs to another. His examples run from minting many digital items together to moving a game character, playing, and placing a resulting trophy in a shared case. The joke is gentle; the engineering aim is serious. Fewer separate approvals and a single all-or-nothing transaction can make complex actions easier to build and use.

Sui reached mainnet in 2023. Blackshear continued discussing the language in terms of the people using it. He worried about education, libraries and the code surrounding a smart contract. In one interview he joked that a typical Sui app could be 5 percent Move and 95 percent front end. The exact split was a joke, but the point was concrete: a safe contract language is only one part of an application that people can understand and operate. His public GitHub profile pins repositories for Sui, Move and tools around the language, a compact record of that practical emphasis.

Proofs, then a faster bug hunt

The bug hunter remained visible inside the CTO. In 2025, Blackshear wrote about the Sui Prover, a tool developed by Asymptotic and made available to Sui developers. Testing checks selected cases. Formal verification asks whether a precisely stated property holds across the cases covered by a proof. A developer might specify that a vault cannot be drained under a set of conditions, or that a balance must be preserved. The result depends on writing the right property and modeling the program correctly; still, it offers a different kind of confidence from a pile of successful test runs.

By April 2026, another tool was changing the pace of that work. Blackshear hosted a conversation with security researchers from Trail of Bits, Asymptotic, Certora and OtterSec about AI in smart-contract security. He offered his own example. He had asked an AI system to port an older static-analysis tool from his Facebook years to Move, run it over Sui programs and flag possible vulnerabilities. The system completed the job fast enough to alter his expectations. His reaction was brief: “It just did it.”

There is a double edge here. If a defender can inspect more code more quickly, so can an attacker. Blackshear’s panel examined what that does to audits, disclosure and the value of public source code. He argued that prominent open-source projects could benefit from scrutiny by people testing powerful models before release. The larger concern was not settled by a single panel, and it did not need to be. The important fact for his own story is that the researcher who once spent days finding bugs by static analysis had watched the speed of that analysis change dramatically.

The founder returns to the workbench

Four months later came the announcement: Blackshear would leave Mysten Labs and join Anthropic for defensive security research. He explained the move in personal, practical terms. He had been happiest, he wrote, doing hands-on technical work while entering new problem areas. He also said he would remain a close adviser to Mysten and to Sui builders who reached out. Move was still a passion after more than eight years, and he hoped to stay involved as a Move Foundation took shape. Evan Cheng would take responsibility for Mysten’s technical vision.

It is tempting to make every founder departure into a verdict on the company left behind. His statement gave a simpler account: a preference for the work itself and an interest in a new security problem. Those are claims about his motives, in his own words, not a guarantee about how the next chapter will unfold. The public career already supplies a clear pattern. At Colorado, he looked for bugs. At Meta, he tried to design some errors out of a language. At Mysten, he helped turn that language into a system developers could use. Now he is working on defense as AI changes the speed and reach of software analysis.

The most useful measure of that career may be the distance between a small bug report and a language used by other people. One fixes a particular flaw. The other tries to change what future code is allowed to do. Blackshear has worked at both scales, with a founder’s responsibilities in between. The work at Anthropic returns him to the scale where he began: looking closely at code, asking what could go wrong, and trying to make the answer less costly for everyone else.