How to Keep Using Cursor Agent Skills with Claude Code After Switching Macs in 2026?

The old Mac works, but the new Mac shows two copies of the same Claude Code skill.

Fastest fix: choose one source before copying anything. Use version-controlled project files for editable skills, or reinstall the Claude Code plugin on the new Mac. Never carry both sources into the same environment.

Last updated August 27, 2026. Installation behavior and the duplicate-install warning were checked against the mattpocock/skills README, the skills package documentation, and Claude Code’s plugin documentation.

This guide is for you if you are moving a Cursor project to a permanent Mac, rebuilding a temporary or cloud Mac, or running Cursor and Claude Code together. It is also useful if your team needs a repeatable handoff instead of a working environment that depends on one old user profile.

2026 Cursor Agent Skills switch to a new Mac

A Mac change does not prevent you from continuing to use Cursor Agent Skills with Claude Code. The migration decision is about the installation source, not the computer.

The mattpocock/skills documentation describes two separate routes:

• Project file route: skills live as editable files that you can inspect, modify, commit, and update yourself.
• Claude Code plugin route: Claude Code manages the installed skill package and its updates.

The README also warns against installing both routes at the same time. That warning matters during a Mac migration because copying project files from the old computer and then installing the plugin on the new computer can expose duplicate skill names.

Record the old Mac’s current route first:

• Check whether the project repository contains the skill files.
• Check whether Claude Code lists an installed plugin.
• Note any local edits that are not committed.
• Record project initialization commands and configuration files.
• Do not delete the old environment until the new one passes a real task.

The only safe default is one active source per skill name.

Can Cursor Agent Skills move with a Git repository?

Yes, when you use the project file route and the skill files are actually tracked by Git. The repository is then the delivery mechanism. A random cache, a hidden global directory, or an uncommitted file on the old Mac is not a reliable migration artifact.

That distinction protects your custom work. If you changed instructions, added scripts, or adjusted project-specific behavior, those changes should appear in a reviewable commit. If they do not, stop and recover them from the old Mac before rebuilding the new environment.

Permanent Mac: repository files versus old-machine state

For a Mac that will become your daily development machine, prefer a repository-driven rebuild when you maintain the skills yourself. This keeps the source close to the project and makes a later machine replacement less dependent on user-level state.

Use this sequence.

Old-Mac inventory

Open the project on the old Mac and identify:

• The skill directory present inside the repository.
• Any nested skill folders or instruction files.
• Local modifications shown by version control.
• Project configuration that controls initialization.
• Scripts or package dependencies required by the skills.
• The last known working commit.

Do not treat the full user directory as the backup. It may contain unrelated caches, credentials, stale generated files, and machine-specific paths.

Repository delivery

Commit the required skill files and project configuration to the approved repository. Push the commit. If the files contain secrets, remove those values and replace them with documented environment variables before committing.

If the project uses a private repository, confirm that the new Mac has the required authentication method. A successful repository clone is not proof that the skills are usable. It only proves that the files arrived.

New-Mac checkout

Clone the repository into the location used by your normal development workflow. Use the current directory and skill-directory rules in the official mattpocock/skills README rather than relying on a path remembered from an older setup.

The installation command should also come from the current documentation. Where the README instructs you to use npx skills add, run that documented command from the intended project context. Do not substitute a global installation unless the current documentation explicitly requires it.

The skills npm package is the right place to verify the current CLI syntax before running a remembered command. Commands and directory conventions can change. A migration article should not freeze an old command as permanent truth.

Project initialization

Run the project’s documented initialization process. Then inspect the resulting files instead of assuming that a successful command means a complete setup.

Check:

• The expected skill files exist.
• Custom instructions match the committed version.
• No duplicate plugin has been enabled for the same skill.
• Project configuration points to the new checkout.
• Claude Code can discover the intended skills.
• Cursor still reads the same project context.

Low-risk validation

Use a harmless task before asking either tool to edit production code. Ask for a narrow operation that reveals whether the intended skill was loaded, such as summarizing a test directory or explaining a small configuration file.

Save the result with the commit or migration record. The important evidence is not a confident response. It is proof that the expected source was visible and that the tool used the intended project context.

What should be reinstalled after changing Macs?

The answer depends on the source. Project files should be delivered through the repository and then initialized on the new Mac. A Claude Code plugin should be installed again through Claude Code’s supported plugin flow. You should not copy plugin-managed read-only content from the old machine and then add the plugin again.

Temporary and cloud Mac: rebuildable environments

A temporary Mac has a different success condition. You are not trying to clone the old computer. You are trying to recreate a known-good working state and leave with the project assets before the machine is released.

This avoids three hidden costs.

First, machine-level state is easy to lose. A skill installed outside the repository may disappear when the environment is reset.

Second, cloud sessions often include short-lived authentication, generated caches, and local paths that have no value on the next machine.

Third, a complete home-directory copy can introduce conflicts. It may bring back an old plugin, an old project file, or a stale configuration that creates the duplicate-source problem you were trying to avoid.

Use the project file route when:

• The task depends on customized skills.
• You need to review or modify instructions during the session.
• The environment will be rebuilt from a repository.
• Cursor and Claude Code must read the same editable project assets.
• You want the skill version tied to a project commit.

Use the plugin route when:

• The task is limited to Claude Code.
• You do not need to edit the installed skill package.
• The plugin is the team’s documented source.
• The environment can be recreated by running the supported Claude Code installation flow.
• You can verify the plugin after each rebuild.

Should a short-lived Mac use the plugin or project files?

Choose project files when reproducibility and local customization matter more than convenience. Choose the plugin when Claude Code is the only consumer and the managed package is the approved source. Do not choose both simply because the temporary machine makes installation easy.

Before destroying the environment, return these assets to the repository or team record:

• Custom skill changes.
• Project configuration changes.
• The commit used for validation.
• The visible skill list.
• The result of the low-risk test.
• Any setup notes needed to recreate the environment.
• A record of whether the source was project files or a plugin.

Do not use a screenshot of the old Mac, a copied cache, or an untracked home-directory folder as the handoff artifact.

Claude Code plugin recovery on a new Mac

A plugin-only setup should be restored as a plugin-only setup. Start from the current Claude Code plugin reference, then use the supported discovery and installation flow documented for the current Claude Code release.

The recovery process is:

1. Start with a clean project checkout.
2. Confirm that the project does not contain a second copy of the same skill.
3. Follow the current Claude Code plugin installation instructions.
4. Confirm that the plugin appears as enabled.
5. Ask Claude Code to show or use the expected skill.
6. Run the project initialization procedure.
7. Restart the session and repeat the discovery check.

The restart check is important. A skill that appears only in one live session may depend on temporary state. You need the new session to discover the same plugin without manual copying.

Use the Claude Code plugin discovery documentation to verify how the current environment searches for and exposes plugins. Do not infer plugin availability from a folder that happens to exist on disk.

If you find a same-named project file after enabling the plugin, stop. Do not continue adding paths or reinstalling the package. First decide which source should remain. Then remove or move the other source according to your repository and team policy, and validate again from a clean session.

Cursor and Claude Code on one new Mac

Running both tools on one Mac does not mean both tools need independent copies of every skill. The safer arrangements are:

• Both tools use one editable project-file source.
• Cursor uses the shared project files, while Claude Code uses only its plugin route.
• Claude Code alone uses the plugin, while Cursor handles the project without installing a second same-named source.

The unsafe arrangement is two same-named sources presented to Claude Code. Tool coexistence is acceptable. Installation-source coexistence is the risk.

Validate the shared setup in separate passes.

Cursor validation

Open the intended repository in Cursor. Confirm that the expected project files are visible and that custom instructions are present. Run a low-risk task that does not modify important code.

Record:

• Which repository revision was open.
• Which skill or instruction was expected.
• Whether Cursor could read the project context.
• Whether the result matched the custom behavior.

Claude Code validation

Start a fresh Claude Code session. Confirm the expected source is discoverable. If Claude Code is using a plugin, verify the plugin state. If it is using project files, verify the repository path and initialization result.

Run a separate low-risk task. Avoid judging the setup solely because the tool produces an answer. Check that the intended skill was available and that no same-named duplicate was selected.

Context validation

Ask both tools to inspect the same harmless project fact. The goal is not to make their responses identical. The goal is to prove that both sessions opened the intended repository and saw the expected configuration.

A different answer may indicate different working directories, ignored files, initialization gaps, or different skill sources. Resolve that difference before using the setup for destructive edits or team delivery.

Migration warning: If you cannot state the single source of truth in one sentence, the environment is not ready to hand off. Stop copying files and decide between repository files and the Claude Code plugin first.

Source selection matrix

Use this comparison before you run an install command. It is a decision tool, not a ranking of one route as universally better.

The matrix leads to a simple rule: choose the route that matches ownership. If you edit the skill, keep it in the repository. If Claude Code manages it and you do not need to modify it, restore the plugin.

Delivery checklist and rollback

Before handing over the new Mac, tick every item:

• [ ] The old Mac’s installation route was recorded.
• [ ] One source was selected for each skill name.
• [ ] Custom changes were committed or intentionally discarded.
• [ ] The repository revision is known.
• [ ] The expected skill directory was checked against current documentation.
• [ ] Project configuration was initialized on the new Mac.
• [ ] Cursor discovery was tested where required.
• [ ] Claude Code plugin or project-file discovery was tested.
• [ ] A low-risk real task completed successfully.
• [ ] A fresh session reproduced the expected skill state.
• [ ] No same-named file and plugin source remain active together.
• [ ] Temporary-environment changes were returned to the repository.
• [ ] Credentials, caches, and machine-specific files were excluded from delivery.

Rollback should reduce complexity, not add another installation layer. For the project-file route, return to the last verified repository commit. For the plugin route, disable the accidental duplicate and restore the single documented plugin source. If the source cannot be identified, return to the last clean checkout and repeat the setup from the official documentation.

Do not use these as delivery evidence:

• A copied global cache.
• An untracked skill folder.
• A machine-specific absolute path.
• A successful command with no discovery check.
• A single session that was never restarted.
• A full user-directory archive containing unknown state.

When a cloud Mac is the better choice

A permanent local Mac is usually the better fit for stable, heavy workloads, persistent physical-device access, or a workflow that needs long-lived local state. A temporary Mac is less suitable when losing the environment would interrupt a continuous production process.

A cloud or temporary Mac becomes useful when you need a clean validation target, a short-lived Cursor and Claude Code test environment, or a reproducible machine for a project handoff. Its value depends on disciplined initialization and delivery. Without a repository-driven setup, you are only moving hidden state to another computer.

If you are evaluating a temporary Mac, start with the MacHTML environment console only after you have defined the repository revision, skill source, validation task, and teardown record. For the broader choice between a short-term machine and a persistent setup, use the MacHTML Mac environment options. The key is to select the environment after defining the rebuild test, not before.

Your current approach may be an old local Mac, a copied home directory, or a cloud machine with manual setup. Those options create different problems: the old Mac preserves undocumented state, a home-directory copy can reintroduce duplicate skills and secrets, and an ad hoc cloud setup disappears without a clean handoff. A MacHTML rental gives you a better fit when you need a temporary Mac for validation, migration, or a controlled Cursor and Claude Code test. Keep the repository as the asset, keep one skill source active, and use the checklist to decide whether the machine is ready to release.

Further reading: Install Agent Skills with a project-scoped, reviewable workflow Compare AI coding tools, memory requirements, and cloud Mac options Use a controlled Apple Silicon migration path when switching Macs