New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Cheap Masm Equivalents

by 0xMiden in 0xMiden/protocol

A skill your agent uses when writing or reviewing MASM hot paths or loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals, neq.0 over…

MITAuto-check passedDevelopment

Install Cheap Masm Equivalents

skills CLI
$ npx skills add 0xMiden/protocol --skill cheap-masm-equivalents -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install 0xMiden/protocol cheap-masm-equivalents --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/0xMiden/protocol.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/cheap-masm-equivalents .claude/skills/cheap-masm-equivalents && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
cheap-masm-equivalents
GitHub stars
133
Token cost
~804 tokens
SKILL.md length
325 words
Files
1
Skills in repo
35
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when writing or reviewing MASM hot paths or loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals, neq.0 over…

  • Reviewing MASM hot paths
  • SKILL.md covers Rule, Why, Examples and Loop Variables Belong on the…
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals

What it does

Cheap Masm Equivalents is an agent skill from 0xMiden/protocol. Use when writing or reviewing MASM hot paths or loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals, neq.0 over gt.0 for non-zero checks, cdrop over an if/else selecting between two values, dup.N over locload for a value still on the stack, eqw over element-wise word comparison, u32gt/u32lt over generic gt/lt on known-u32 operands.

Its SKILL.md is about 800 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development. The repository describes itself as: Core components of the Miden protocol. The licence is MIT.

When your agent uses it

  • Reviewing MASM hot paths
  • Loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals
  • Neq.0 over gt.0 for non-zero checks
  • Cdrop over an if/else selecting between two values

Example prompts

  • “/cheap-masm-equivalents”

What it can do on your machine

Read from SKILL.md and the folder at commit 62b59ec. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are masm).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Cheap Masm Equivalents loads about 804 tokens when it runs. Until then it costs about 111 tokens; SKILL.md has 325 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~111
When it runs · the whole SKILL.md, loaded when a task matches
~804

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from 0xMiden/protocol at commit 62b59ec, republished under its MIT licence (© 0xMiden). 325 words, ~804 tokens.

Download SKILL.mdSave it as .claude/skills/cheap-masm-equivalents/SKILL.md (or your agent's skills folder).
name
cheap-masm-equivalents
description
Use when writing or reviewing MASM hot paths or loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals, `neq.0` over `gt.0` for non-zero checks, `cdrop` over an `if/else` selecting between two values, `dup.N` over `loc_load` for a value still on the stack, `eqw` over element-wise word comparison, `u32gt`/`u32lt` over generic `gt`/`lt` on known-u32 operands.

Prefer Cheap MASM Equivalents

Rule

Several MASM idioms have a cheap and an expensive form. Use the cheap one when both produce the same result on the inputs the procedure can see:

  • Loop variables (counters, pointers, indices): keep them on the operand stack across iterations instead of in procedure locals. See below.
  • Non-zero check: neq.0 (3 cycles) over gt.0 (16 cycles).
  • Selecting between two values on a flag: cdrop over an if.true ... else ... end branch with the same effect.
  • Re-fetch a recently-pushed value: dup.N over loc_load.N when the value is still on the stack.
  • Whole-word equality: eqw over element-wise comparisons.
  • u32-known operands: u32gt/u32lt over generic gt/lt.

Don't apply the cheap form when the operands violate its precondition (e.g. u32gt on a value that might exceed u32::MAX).

Why

MASM cycle costs are not uniform — gt.0 does signed-comparison work that neq.0 skips, so a hot path using the expensive form pays for it on every call. The swaps are semantically equivalent under their preconditions, so the saving is free.

Examples

masm
# Good
push.0 neq          # non-zero check, 3 cycles
# or simply
neq.0

# Bad
push.0 gt           # same answer, 16 cycles
masm
# Good: cdrop for ternary selection
# stack: [c, b, a]
cdrop
# stack: [b if c = 1 else a]

# Bad: branchy equivalent
if.true
    swap drop # drop a, keep b
else
    drop      # drop b, keep a
end

Loop Variables Belong on the Stack

A procedure local is not a register: loc_load.i costs 5 cycles and loc_store.i costs 6. Reaching the same value on the stack with dup.n, swap, movup.n or movdn.n (usually) costs 1 cycle. So a loop that keeps its counter and pointer in locals pays 5-11 cycles per access, per iteration, for data the stack could hold for 1.

Read once, mutate in place:

masm
# Good: item_ptr lives on the stack next to the loop counter
# => [items_left, item_ptr, ...]
# 1 cycle: read the pointer
dup.1
# ... use it ...
# 4 cycles: advance it
swap add.ITEM_NUM_ELEMENTS swap
sub.1 dup neq.0

# Bad: same loop through a local
# 5 cycles
loc_load.ITEM_PTR_LOC
# ... use it ...
# 13 cycles
loc_load.ITEM_PTR_LOC add.ITEM_NUM_ELEMENTS loc_store.ITEM_PTR_LOC
sub.1 dup neq.0
Working around call

The reason to reach for a local is a call: the callee takes the top 16 elements, so while those 16 slots are being filled, nothing below them is addressable by dup.n. Values that only have to survive the call are fine on the stack - they sit in the overflow and come back untouched. Only a value that must be re-read while the frame is being built has to live in a local, and even then it is one local, not one per loop variable.

© 0xMiden, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/cheap-masm-equivalents of 0xMiden/protocol.

Open the folder on GitHubat commit 62b59ec

Compare with similar skills

Cheap Masm Equivalents next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Cheap Masm Equivalents compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Cheap Masm Equivalents this skill0xMiden/protocol133—~804Automated safety check: PassMIT
Vercel Composition Patternssupabase/supabase111k58 repos~726Automated safety check: PassMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
Typescript Advanced Typesrolling-scopes/rsschool-app10k25 repos~4.2kAutomated safety check: PassMPL-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k4 repos~1.1kAutomated safety check: PassMIT

Similar skills

  • Vercel Composition Patterns

    supabase/supabase

    Official

    React composition patterns that scale. An agent skill from supabase/supabase.

    111k GitHub starsUsed in 58 repos~726 tokens
    DevelopmentAuto-check passed

  • Finishing a Development Branch

    obra/superpowers

    Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Typescript Advanced Types

    rolling-scopes/rsschool-app

    Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.

    10k GitHub starsUsed in 25 repos~4.2k tokens
    DevelopmentAuto-check passed

  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 4 repos~1.1k tokens
    DevelopmentAuto-check passed

  • Greploop

    onyx-dot-app/onyx

    Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.

    32k GitHub starsUsed in 4 repos~3.3k tokens
    DevelopmentAuto-check passed

More from 0xMiden/protocol

All 35 skills in this repo

  • Advice Provider Hygiene

    0xMiden/protocol

    A skill your agent uses when writing kernel, account, or note MASM code that reads from or writes to the advice provider (advice stack / advice map) — validate advice data.

    133 GitHub stars~1.1k tokensUpdated yesterday
    Auto-check passed

  • Concise Changelog Entries

    0xMiden/protocol

    Keep CHANGELOG.md entries to a single concise sentence. An agent skill from 0xMiden/protocol.

    133 GitHub stars~805 tokensUpdated yesterday
    Auto-check passed

  • Concise PR And Issue Descriptions

    0xMiden/protocol

    Keep PR and issue descriptions short and decision-focused. An agent skill from 0xMiden/protocol.

    133 GitHub stars~1.8k tokensUpdated yesterday
    Auto-check passed

  • Conversion Method Naming

    0xMiden/protocol

    A skill your agent uses when naming a conversion or accessor method in Rust — follow the Rust API naming conventions for the method's cost and ownership.

    133 GitHub stars~450 tokensUpdated yesterday
    Auto-check passed

  • Decouple Component From Storage

    0xMiden/protocol

    A skill your agent uses when writing a generic MASM utility that accesses a caller-selected account storage slot — receive the slot as a parameter so the utility is portable across storage layouts.

    133 GitHub stars~529 tokensUpdated yesterday
    Auto-check passed

  • Felt Construction

    0xMiden/protocol

    A skill your agent uses when constructing a Felt from a numeric value in Rust — use checked construction unless the canonical bound is already proved.

    133 GitHub stars~439 tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Cheap Masm Equivalents

What does Cheap Masm Equivalents do?

A skill your agent uses when writing or reviewing MASM hot paths or loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals, neq.0 over…. Cheap Masm Equivalents is an agent skill from 0xMiden/protocol.N over locload for a value still on the stack, eqw over element-wise word comparison, u32gt/u32lt over generic gt/lt on known-u32 operands.

When should I use Cheap Masm Equivalents?

Cheap Masm Equivalents fits situations like: reviewing MASM hot paths; loops — prefer the cheaper equivalent: loop counters and pointers on the operand stack instead of procedure locals; neq.0 over gt.0 for non-zero checks; cdrop over an if/else selecting between two values.

How do I install Cheap Masm Equivalents in Claude Code?

Run `npx skills add 0xMiden/protocol --skill cheap-masm-equivalents -a claude-code`. Or copy the skill folder (.claude/skills/cheap-masm-equivalents in 0xMiden/protocol) into .claude/skills/cheap-masm-equivalents in your project. Claude Code loads it when a task matches its description.

How do I install Cheap Masm Equivalents in Codex?

Run `npx skills add 0xMiden/protocol --skill cheap-masm-equivalents -a codex`. Or copy the skill folder (.claude/skills/cheap-masm-equivalents in 0xMiden/protocol) into .agents/skills/cheap-masm-equivalents in your project. Codex loads it when a task matches its description.

Can I use Cheap Masm Equivalents in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add 0xMiden/protocol --skill cheap-masm-equivalents -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/cheap-masm-equivalents, .gemini/skills/cheap-masm-equivalents, .github/skills/cheap-masm-equivalents and .opencode/skills/cheap-masm-equivalents in your project.

What does Cheap Masm Equivalents need to run?

SKILL.md names no scripts, command-line tools or credentials: Cheap Masm Equivalents is instructions for the agent only.

Does Cheap Masm Equivalents access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Cheap Masm Equivalents safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Cheap Masm Equivalents use?

Cheap Masm Equivalents is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Cheap Masm Equivalents use?

About 804 tokens (SKILL.md is roughly 3.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Cheap Masm Equivalents?

Skills that share tags, products or a category with Cheap Masm Equivalents: Vercel Composition Patterns (supabase/supabase, 111k stars), Finishing a Development Branch (obra/superpowers, 297k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars) and PR Babysitter (openinterpreter/openinterpreter, 69k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Cheap Masm Equivalents?

0xMiden (a GitHub organization) maintains it in 0xMiden/protocol, which has 133 GitHub stars. The repository holds 35 skills in this directory. The repository was last updated on October 9, 2026.

Source: 0xMiden/protocol on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.