Add the skill faster_rust_worktrees: create the Git worktrees of a Rust repository fast and small on the disk

Start by reading skills/issue_fix_workflow/SKILL.md and the referenced worktree_tools README to understand the existing worktree workflow and reference implementation. Find the Rust package build and test commands, then follow the issue’s steps for the Cargo workspace, worktree creation and cleaning commands, and the AGENTS.md workflow update. Done means locked versions remain unchanged, tests pass, and measurements show the reported worktree build and disk space improvements.

Goal

Add a skill faster_rust_worktrees in skills, with a file SKILL.md. With this skill, a coding agent makes the Git worktrees of any Rust repository fast to create and small on the disk. Each issue fix creates a new worktree, and without this technique the first build of each worktree compiles every Rust dependency again.

The technique was proven first in Heidrun Code, then applied to the repository localai_rust:

• https://github.com/heidrun-org/localai_rust/issues/14
• https://github.com/heidrun-org/heidrun_code/issues/864

Measures in localai_rust

Measured on 2026-10-29 on an Apple M1 Pro, in fresh clones (the comments of the issue of localai_rust give the details):

The technique

1. Make all the Rust packages of the repository one Cargo workspace at the root, with one Cargo.lock and one target folder. The packages then share their compiled dependencies, and Cargo uses relative paths for the packages of the repository, so the compiled files stay valid in a worktree. To keep the locked versions, start the new Cargo.lock from the largest old one, and check that no locked version changed.
2. Create each worktree with a command that clones the target folder of the main checkout into the worktree, with one copy-on-write clone: the function clonefile of macOS (through python3), with cp -c -R -p as the fallback. The clone takes about 2 seconds and shares the disk blocks until Cargo writes a file again.
3. Give each tracked file with the same content as in the main checkout the modification date of the main checkout, and each folder with the same list of names. Git gives every file of a new worktree the date of the creation, and Cargo then compiles every crate of the repository again.
4. In the build script records target/<debug or release>/build/*/output, replace the absolute path of the main checkout with the path of the worktree, for the folder of the packages and for the target folder, and keep the date of each record.
5. Install the packages of the worktree (for example pnpm install --frozen-lockfile).
6. Give an option --without-optimization that only creates the worktree, to find out whether a problem comes from these optimizations.
7. Give two cleaning commands: one that deletes the target folders of the worktrees that no build used for some days, and one that deletes the files of the target folder that the current builds do not use (from the hashes of the units in the Cargo log CARGO_LOG=cargo::core::compiler::fingerprint=debug).

Traps found in localai_rust

• Run Cargo in the folder of each package, as the scripts of the package do, and never at the root of the workspace. At the root, Cargo builds the packages together, which gives the shared dependencies other features and other hashes, and it does not read the .cargo/config.toml of a package. Both make Cargo compile everything again.
• Run each Cargo command of the cleaning command in the folder of its package, for the same reason. A variable such as GGML_METAL, set in the .cargo/config.toml of a package, makes a build script run again when it changes.
• The worktree must be inside the main checkout (for example .agents/worktrees/<branch>), so that both folders are on the same disk, which the clone needs.
• The main checkout must be built first. Without a target folder, the command creates the worktree without the clone and says so.
• Measure with the real repository: count the lines Compiling of the first build in a new worktree. The result must be 0 crates when no source changed, and only the changed package after a change of one line.

What the skill does

The skill names no detail of one repository, like the skill issue_fix_workflow. It tells the coding agent to:

1. Find the Rust packages of the repository, the commands that build and test them, and the folder of the worktrees.
2. Make the Cargo workspace, and check that the locked versions did not change and that the tests pass.
3. Add the command that creates a worktree, and the two cleaning commands. The package worktree_tools of localai_rust is the reference implementation, in TypeScript.
4. Change the worktree creation command of the Issue Fix Workflow in the file AGENTS.md of the repository.
5. Measure before and after, as in the table above, and write the measures in the issue.