Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add MystenLabs/skills --skill modern-move-syntax -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/modern-move-syntax/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/modern-move-syntax/

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

Similar skills

All skills for Programming languages →

From the same set30

The whole set →
sui-object-model The sui-object-model Claude Code skill covers Sui objects and helps answer questions about ownership, transfers, and data storage in Sui Move. It activates for choices between ownership types or storage patterns. CX Codex +1 617installs composable-move-functions composable-move-functions — a skill for Claude Code enforces conventions for Sui Move function signatures. It activates when designing public APIs, ordering parameters, and handling object returns for PTB composition. CX Codex +1 616installs move-unit-testing The move-unit-testing Claude Code skill guides unit testing for Move smart contracts on Sui. It activates when asked to write tests or add them to a Move module. CX Codex +1 615installs sui-build The sui-build Claude Code skill guides Move package builds with sui move build. The agent uses it for Move coding and questions about the build command. CX Codex +1 613installs accessing-data accessing-data — a skill for Claude Code that guides data fetching on Sui across gRPC, GraphQL RPC, Archival Store, Walrus, and sui-indexer-alt. Triggers on queries about balances, objects, and JSON-RPC migrations. CX Codex +1 491installs ptbs ptbs — a skill for Claude Code helps write, review, and debug Sui Programmable Transaction Blocks. It applies to TypeScript SDK and CLI transactions, gas handling, and sponsored flows. CX Codex +1 491installs sui-sdks sui-sdks — a Claude Code skill for navigating the Sui blockchain SDK ecosystem and wiring up projects. It triggers when starting a Sui project, porting code, or comparing SDK APIs. CX Codex +1 487installs frontend-apps The frontend-apps Claude Code skill guides frontend work on Sui browser apps. It covers wallet connections, on-chain queries, and transaction flows. CX Codex +1 479installs

Project sponsors

Companies that keep this analytics open