How to use the Migrate Legacy Code to Safe Rust skill

What does the migrate-to-rust skill make the agent do?

The skill tells the agent to act as a systems architect, performance engineer and Rust specialist. It works on legacy C++, Fortran, Java, Python, C and Shell codebases. The source describes a staged process: the agent first records baseline measurements of the original program, then writes an architectural blueprint, implements a Rust version, and checks that its output matches the original.

During the work the agent logs timings and results to a JSON file (migration_telemetry.json) through a bundled Python script, scripts/telemetry.py. It can also produce a written report and an interactive HTML summary page (migration_infographic.html).

• Stage 0: clone or scan the codebase, detect the language, and benchmark the legacy program
• Stage 1: audit the code, log opportunities and latent bugs, and write a six-section blueprint
• Stage 2: scaffold a #![forbid(unsafe_code)] Rust workspace, implement it, run tests, run A/B parity checks, and optionally apply LLVM profile-guided optimization
• Output: telemetry JSON, a report, and an HTML infographic

How do I install the migrate-to-rust skill?

Download the skill ZIP from this page. Then choose one of two routes depending on how you use your agent.

For Claude Code, unzip the download into your personal skills folder ~/.claude/skills/, or into a project's .claude/skills/ folder if you want the skill available only in that project. Keep the skill's folder contents intact, including SKILL.md, the scripts folder and the references folder.

In the Claude apps, open Settings, go to Capabilities, then Skills, and upload the skill there.

• Route 1 (Claude Code): unzip into ~/.claude/skills/ (all projects) or .claude/skills/ (one project)
• Route 2 (Claude apps): Settings → Capabilities → Skills, then upload

What do you need installed before it works?

The skill depends on several tools. Check these before you start a migration, because the agent will need them during the build and test stages.

The source lists git for cloning repositories, a Rust toolchain with cargo and clippy, and Python 3 to run scripts/telemetry.py. Two items are optional: llvm-profdata for profile-guided optimization benchmarks, and the proptest crate and Criterion for property-based tests and benchmarks.

• Required: git (to clone repositories)
• Required: Rust toolchain with cargo and clippy
• Required: Python 3 (to run scripts/telemetry.py)
• Optional: llvm-profdata (PGO benchmarking; the source says the PGO benchmark stage is omitted cleanly if it is missing)
• Optional: proptest crate and Criterion (tests and benchmarks)

How do I trigger the skill with a natural request?

You do not need a special command. Describe the migration in plain language and name the source. The skill's own description lists the kinds of requests it is meant for: migrating a GitHub repository or local codebase to Rust, porting legacy C++, Fortran, Python or Java workloads to memory-safe Rust, designing Struct-of-Arrays or SIMD Rust architectures, and optimizing Rust ports with LLVM PGO.

Be specific about the source and the goal. Giving the GitHub URL or folder path lets the agent start Stage 0 right away.

• Migrate this C++ repository to safe Rust: https://github.com/owner/repo (replace with your URL)
• Port the Fortran code in ./solver to Rust and compare the outputs with the original
• Plan and migrate this local Python project to Rust, and benchmark before and after
• Port this Java workload to Rust with a documented parity check against the original
• Migrate this codebase to Rust and produce an HTML summary of the benchmarks

What happens during a migration, step by step?

The skill begins by cloning the repository into a local folder, by default ~/rust_migrations/{repo_name}. It then initializes the telemetry ledger and scans the legacy code. Before the agent compiles or runs any code from a cloned external repository, it must show you the resolved build command, run command and working directory and wait for your confirmation.

The source sets a retry budget of 5 self-healing iterations for failing tests, clippy lints or parity checks. If a test still diverges after that budget, the agent records the partial state and documents the remaining gap in the final report instead of looping.

• Clone: git clone {github_url} ~/rust_migrations/{repo_name}
• Initialize telemetry: scripts/telemetry.py init --telemetry "{workspace_dir}/migration_telemetry.json" --project-name "{project_name}" --legacy-lang "{legacy_language}"
• Scan the legacy code: scripts/telemetry.py scan-codebase --phase before
• Benchmark the baseline: scripts/telemetry.py log-benchmark --stage legacy_baseline
• Start the blueprint phase: scripts/telemetry.py start-bucket --bucket blueprint
• Render the report page: scripts/telemetry.py render-infographic

What do the benchmark and parity checks measure?

The skill expects four benchmark stages to be measured and logged: legacy_baseline, safe_rust, soa_simd and pgo_lto. The baseline measures wall-clock runtime in milliseconds and peak RSS in megabytes. Parity is checked across N deterministic seeds, within a numerical tolerance you can set with the --max-abs-error flag. Any floating-point, FMA or PRNG divergence is meant to be root-caused and logged.

The source also sets verification targets: zero cargo clippy warnings for the Rust crate (any exception must be documented) and a branch coverage target of at least 95% (again, documented exceptions only).

• Benchmark stages: legacy_baseline, safe_rust, soa_simd, pgo_lto
• Parity: N deterministic seeds within --max-abs-error
• Clippy target: 0 warnings
• Coverage target: 95% or more branch coverage

What safety points should I check first?

This skill runs scripts and uses the network. It clones repositories with git and runs scripts/telemetry.py. The skill also executes cloned build and run commands after you confirm them. Those commands can run arbitrary code from that repository, so the confirmation step is a real safety check, not a formality. Read the resolved commands and the working directory before you approve.

The source says not to run untrusted cloned repositories without review. Inspect the build files, README and CI workflows yourself first when the code is unfamiliar.

• Read every build and run command shown at the confirmation gate before approving
• Review the repository's build files and scripts before you run them
• Use a local folder you already trust if you do not know the repository
• The skill does not apply to unrelated refactors or single-line Rust syntax questions, which the skill itself says it should not handle