modern-move-syntax — Claude Code skill: what it does, how to install
modern-move-syntax — a skill for Claude Code that enforces Move 2024 edition syntax for Sui smart contracts. It replaces legacy module calls with method dot notation, loop macros, and clean literals.
Apache-2.0 613 installs ★ 25 updated 2026-11-12
npx skills add MystenLabs/skills --skill modern-move-syntax -a claude-codeWhat modern-move-syntax does
This skill guides the agent to use Move 2024 edition syntax whenever generating code for Sui. Language models frequently output pre-2024 module calls because of their training corpora. The rules enforce method-call dot notation across Coin, Balance, and TxContext operations.
The skill includes rules for direct string literals, index access on collections, and struct unpacking via ... It introduces loop and option macros such as do!, fold!, and destroy_or!, alongside tuple structs and enum types handled with match blocks.
If available in the environment, the agent can verify syntax rules against the Sui documentation MCP server at https://sui.mcp.kapa.ai.
What it helps with
- replace legacy Move module calls with dot-notation methods
- switch string conversions to direct quoted literals
- simplify iteration and option handling using Move 2024 macros
- unpack structs cleanly using
..to skip unused fields
Example prompts for the agent
- Write a Sui token transfer function using Move 2024 method syntax
- Refactor this module to eliminate legacy balance::join calls and while loops
- Define an enum with pattern matching for a Sui smart contract
How to install modern-move-syntax
1Skills CLI (Vercel)
npx skills add MystenLabs/skills --skill modern-move-syntax -a claude-code2Manually: put the files in place
~/.claude/skills/modern-move-syntax/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/modern-move-syntax/
1Skills CLI (Vercel)
npx skills add MystenLabs/skills --skill modern-move-syntax -a codex2Manually: put the files in place
.agents/skills/modern-move-syntax/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add MystenLabs/skills --skill modern-move-syntax -a cursor2Manually: put the files in place
.cursor/skills/modern-move-syntax/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install MystenLabs/skills modern-move-syntax2Manually: put the files in place
.github/skills/modern-move-syntax/SKILL.md1Skills CLI (Vercel)
npx skills add MystenLabs/skills --skill modern-move-syntax -a gemini-cli2Platform CLI
gemini skills install https://github.com/MystenLabs/skills --path modern-move-syntaxManually: put the files in place
.devin/skills/modern-move-syntax/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add MystenLabs/skills --skill modern-move-syntax -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about modern-move-syntax
How to install modern-move-syntax in Claude Code?
Run npx skills add MystenLabs/skills --skill modern-move-syntax -a claude-code. Alternatively, place the skill file at ~/.claude/skills/modern-move-syntax/SKILL.md.
What does modern-move-syntax do?
It instructs the agent to write Sui smart contracts with 2024 edition features, replacing legacy module functions with method syntax, macros, and enums.
What is needed for modern-move-syntax to work?
The skill requires no external API keys. It can optionally query the Sui documentation MCP server at https://sui.mcp.kapa.ai if configured.
Source text
SKILL.md · Apache-2.0
---
name: modern-move-syntax
description: Use when writing Move code on Sui to ensure 2024 edition syntax is used. Applies to method calls, string literals, vector operations, option handling, loops, and struct unpacking. Use whenever writing Move code to avoid legacy function-call syntax patterns.
---
# modern-move-syntax
> **MCP tool:** When available in your environment, also query the Sui documentation MCP server (`https://sui.mcp.kapa.ai`) for up-to-date answers. Use it for verification and for details not covered by these reference files.
## Overview
The Move 2024 edition introduced method syntax and several convenience features. AI agents frequently fall back to pre-2024 function-call patterns from training data. This skill covers every modern syntax pattern.
All patterns sourced from https://move-book.com/guides/code-quality-checklist
## Method Syntax for Common Operations
Use method-call syntax (dot notation) instead of module function calls.
### Coin and Balance
```move
// WRONG — legacy function-call syntax
let value = coin::value(&payment);
let balance = coin::into_balance(payment);
balance::join(&mut pool.reserve, balance);
let coin = coin::from_balance(balance::split(&mut pool.reserve, amount), ctx);
// CORRECT — method syntax
let value = payment.value();
let balance = payment.into_balance();
pool.reserve.join(balance);
let coin = coin::from_balance(pool.reserve.split(amount), ctx);
// BEST — chained method calls
let balance = payment.split(amount, ctx).into_balance();
```
### TxContext
```move
// WRONG
tx_context::sender(ctx)
// CORRECT
ctx.sender()
```
### UID and Object
```move
// WRONG
object::delete(id);
// CORRECT
id.delete();
```
## String Literals
Use quoted string literals directly, not `std::string::utf8()` or byte-string conversion.
```move
// WRONG
use std::string;
let s = string::utf8(b"hello");
// ALSO WRONG — unnecessary conversion
let s = b"hello".to_string();
// CORRECT — direct string literals (2024 edition)
let s = "hello"; // String (UTF-8)
let ascii = "hello"; // also works for ASCII strings
let s = b"hello".to_string(); // still valid but prefer quoted form
let ascii = b"hello".to_ascii_string(); // explicit ASCII when needed
```
## Vector Literals and Methods
Use vector literal syntax and method calls instead of module functions.
```move
// WRONG
let mut v = vector::empty();
vector::push_back(&mut v, 10);
let first = vector::borrow(&v, 0);
let len = vector::length(&v);
// CORRECT
let mut v = vector[10];
let first = &v[0];
let len = v.length();
v.push_back(20);
```
### Collection Index Syntax
```move
// WRONG
let val = vec_map::get(&map, &key);
// CORRECT
let val = &map[&key];
```
## Option Macros
Use macros instead of manual `is_some` / `destroy_some` patterns.
```move
// WRONG
if (opt.is_some()) {
let value = opt.destroy_some();
call_function(value);
};
// CORRECT
opt.do!(|value| call_function(value));
```
### Default values
```move
// WRONG
let value = if (opt.is_some()) { opt.destroy_some() } else { default };
// CORRECT
let value = opt.destroy_or!(default);
```
## Loop Macros
```move
// WRONG — manual counter loop
let mut i = 0;
while (i < 32) {
do_action();
i = i + 1;
};
// CORRECT — do! macro
32u8.do!(|_| do_action());
```
### Range-based loops
```move
// Iterate over a numeric range
let mut sum = 0;
10u64.do!(|i| { sum = sum + i }); // i goes 0..9
// With index for more complex logic
let mut results = vector[];
5u64.do!(|i| results.push_back(i * i)); // [0, 1, 4, 9, 16]
```
### Vector iteration
```move
// WRONG
let mut i = 0;
while (i < vec.length()) {
call_function(&vec[i]);
i = i + 1;
};
// CORRECT
vec.do_ref!(|e| call_function(e));
```
### Vector creation from range
```move
// WRONG
let mut v = vector[];
let mut i = 0;
while (i < 32) { v.push_back(i); i = i + 1; };
// CORRECT
let v = vector::tabulate!(32, |i| i);
```
### Fold and filter
```move
// fold
let sum = source.fold!(0, |acc, v| { acc + v });
// filter (requires T: drop)
let filtered = source.filter!(|e| e > 10);
```
## Struct Unpacking: `..` Syntax
Use `..` to ignore unused fields when destructuring in 2024 edition.
```move
// WRONG
let MyStruct { id, field_1: _, field_2: _, field_3: _ } = value;
// CORRECT
let MyStruct { id, .. } = value;
```
## Renamed Standard Library Functions
Some standard library functions have been renamed. Using the old name produces a deprecation warning or compile error.
```move
// WRONG — deprecated, renamed
dynamic_field::exists_(&id, key)
// CORRECT
dynamic_field::exists(&id, key)
```
## Positional Fields (Tuple Structs)
Structs can use positional fields instead of named fields:
```move
// Named fields (traditional)
public struct Wrapper has copy, drop, store { value: u64 }
// Positional fields (2024 edition)
public struct Wrapper(u64) has copy, drop, store;
// Access by position
let w = Wrapper(42);
let val = w.0;
```
Positional structs are useful for newtype wrappers and dynamic field keys (see `naming-conventions` skill).
## Public Structs
The `public` keyword on structs controls visibility of the struct's fields. Without `public`, fields are module-private — only the defining module can construct or destructure the struct.
```move
// Fields visible only within this module
struct Config has key { id: UID, admin: address }
// Fields visible to other modules
public struct Token has key, store { id: UID, value: u64 }
```
Use `public` when other modules need to read fields or construct/destructure the struct. Omit it for encapsulation.
## Enums
Move 2024 supports enum types:
```move
public enum Color {
Red,
Green,
Blue,
Custom(u8, u8, u8),
}
public fun is_red(c: &Color): bool {
match (c) {
Color::Red => true,
_ => false,
}
}
```
Enums can have variants with positional fields, named fields, or no fields. Use `match` expressions for exhaustive pattern matching. Enums cannot have the `key` ability — they cannot be objects directly, but they can be stored as fields inside objects.
## Quick Reference
| Legacy Pattern | Modern 2024 Syntax |
|---|---|
| `coin::value(&c)` | `c.value()` |
| `coin::into_balance(c)` | `c.into_balance()` |
| `balance::join(&mut b, v)` | `b.join(v)` |
| `balance::split(&mut b, n)` | `b.split(n)` |
| `tx_context::sender(ctx)` | `ctx.sender()` |
| `object::delete(id)` | `id.delete()` |
| `string::utf8(b"x")` | `"x"` (or `b"x".to_string()`) |
| `vector::empty()` | `vector[]` |
| `vector::push_back(&mut v, x)` | `v.push_back(x)` |
| `vector::length(&v)` | `v.length()` |
| `opt.is_some() + destroy_some` | `opt.do!(\|v\| ...)` |
| `while (i < n) { ... i++ }` | `n.do!(\|_\| ...)` |
| `let S { a, b: _ } = x` | `let S { a, .. } = x` |
© MystenLabs · Apache-2.0 · MystenLabs/skills