This page explains how to install the agent skill of the Fanuc SDK in an AI coding agent: Claude Code, Codex, GitHub Copilot, Cursor and about 70 other agents that read skills. There is one skill for C# and one for Python, and each skill documents one version of the SDK.

## What the skill does

A skill is a folder with a `SKILL.md` file and reference files. The agent loads it when a question or a task is about the Fanuc SDK. The skill contains:

- the pages of this documentation, with the code samples in the language of the skill;
- every public type and member of the SDK, one line each;
- the exceptions of the SDK and what to check;
- the choice of the protocol and of the controller option for a task, the motion safety rules, and the rules that stop the agent from inventing members.

With the skill, the agent answers questions such as "why do I get an `InvalidLicenseException`?" or "what is the difference between SNPX and CGTP?", and writes code such as "write an app that reads the position registers" or "make my Fanuc robot draw an ellipse".

| Language    | Skill                          | Plugin         | Package                      |
| ----------- | ------------------------------ | -------------- | ---------------------------- |
| C# and .NET | `underautomation-fanuc-csharp` | `fanuc-csharp` | NuGet `UnderAutomation.Fanuc` |
| Python      | `underautomation-fanuc-python` | `fanuc-python` | pip `UnderAutomation.Fanuc`   |

Install the skill of the language of your project only: the .NET API uses PascalCase and the Python API uses snake_case. The skills are generated from this documentation at each release of the SDK and published in the repository [underautomation/skills](https://github.com/underautomation/skills), under the MIT license. Installing a skill does not give a license of the SDK: see [Licensing](/fanuc/documentation/license).

## Ask your agent to install it

Open your agent in the folder of your project and paste this prompt:

```plaintext
Install the UnderAutomation Fanuc skill: follow https://underautomation.com/fanuc/documentation/ai-skills.md
```

The agent reads the Markdown version of this page and follows its last section, "Instructions for AI agents". It finds the language of the project, installs the skill and checks its version. It asks a question only when the project has no C# or Python file to find the language.

You can also install the skill yourself, with one of the 4 methods below. Replace `csharp` with `python` for the Python skill.

## Install with Claude Code

```bash
claude plugin marketplace add underautomation/skills
claude plugin install fanuc-csharp@underautomation
```

Inside a Claude Code session, the same commands are `/plugin marketplace add underautomation/skills` and `/plugin install fanuc-csharp@underautomation`. Add `--scope project` to `claude plugin install` to share the plugin with the other developers of the project.

## Install with Codex

```bash
codex plugin marketplace add underautomation/skills
```

Then open Codex, run `/plugins`, select the UnderAutomation marketplace and install `fanuc-csharp`.

## Install with npx skills

With Node.js installed, [skills](https://github.com/vercel-labs/skills) installs the skill for GitHub Copilot, Cursor, Gemini CLI, OpenCode and about 70 other agents, Claude Code and Codex included:

```bash
npx skills add underautomation/skills --skill underautomation-fanuc-csharp
```

Add `-y` to skip the questions, `-a <agent>` to choose the agent (`claude-code`, `codex`, `github-copilot`, `cursor`...) and `-g` to install for the user instead of the project.

## Install manually

Download the zip of the skill from the latest release of [underautomation/skills](https://github.com/underautomation/skills/releases/latest):

- C#: [underautomation-fanuc-csharp.zip](https://github.com/underautomation/skills/releases/latest/download/underautomation-fanuc-csharp.zip)
- Python: [underautomation-fanuc-python.zip](https://github.com/underautomation/skills/releases/latest/download/underautomation-fanuc-python.zip)

The zip contains one folder, for example `underautomation-fanuc-csharp/`. Extract it into the skills folder of your agent:

| Agent          | Project folder    | User folder                                 |
| -------------- | ----------------- | ------------------------------------------- |
| Claude Code    | `.claude/skills/` | `~/.claude/skills/`                         |
| Codex          | `.agents/skills/` | `~/.agents/skills/`                         |
| GitHub Copilot | `.agents/skills/` | `~/.copilot/skills/` or `~/.agents/skills/` |
| Cursor         | `.agents/skills/` | `~/.cursor/skills/` or `~/.agents/skills/`  |

A project folder is relative to the root of the project, and is shared with the other developers when you commit it. On Windows, `~` is `%USERPROFILE%`. After the extraction, the file `.claude/skills/underautomation-fanuc-csharp/SKILL.md` (or the same path in the folder of your agent) must exist.

The link of the zip always gives the last version. To install the skill in claude.ai, upload the same zip in the skills settings.

## Check the version

The frontmatter of `SKILL.md` gives the SDK version that the skill documents, for example:

```yaml
metadata:
  sdk-version: 7.1.0
```

Compare it with the version of the package of your project:

- C#: `dotnet list package`, line `UnderAutomation.Fanuc`
- Python: `pip show UnderAutomation.Fanuc`, line `Version`

When the versions differ, update the skill (`claude plugin update fanuc-csharp@underautomation`, `npx skills update`, or download the zip again), or update the package. The agent also does this check before it writes code for the SDK.

## Instructions for AI agents

This section is for an AI agent that a user asked to install the UnderAutomation Fanuc skill. Follow the 4 steps in order. Do not run any script other than the commands of this section. Ask the user a question only in step 1, and only when the language cannot be found.

### Step 1: find the language

Look at the files of the current project folder and of its subfolders:

- a `*.csproj` file (or a `*.sln` or `*.slnx` file) means C#: the skill is `underautomation-fanuc-csharp`;
- a `pyproject.toml` or `requirements.txt` file means Python: the skill is `underautomation-fanuc-python`;
- with both, install the two skills;
- with neither, ask the user: "C# or Python?". Ask nothing else.

### Step 2: install with npx skills when Node.js is installed

Run `node --version`. If it works, run this command at the root of the project, with the skill of step 1 and the identifier of the agent that you are:

```bash
npx --yes skills add underautomation/skills --skill underautomation-fanuc-csharp -a claude-code -y
```

| Agent          | `-a` identifier  | Skills folder of the project |
| -------------- | ---------------- | ---------------------------- |
| Claude Code    | `claude-code`    | `.claude/skills/`            |
| Codex          | `codex`          | `.agents/skills/`            |
| GitHub Copilot | `github-copilot` | `.agents/skills/`            |
| Cursor         | `cursor`         | `.agents/skills/`            |

For another agent, use its identifier in `npx skills`, or leave out `-a`. The first `--yes` answers the download question of npx, the last `-y` the questions of `skills`. If Node.js is not installed or the command fails, go to step 3. Otherwise, go to step 4.

### Step 3: otherwise, download the zip

Download the zip of the skill from the latest release and extract it into the skills folder of the project of the table above. The zip contains the folder of the skill. Example for Claude Code and the C# skill, with Bash:

```bash
curl -L -o underautomation-fanuc-csharp.zip https://github.com/underautomation/skills/releases/latest/download/underautomation-fanuc-csharp.zip
mkdir -p .claude/skills
unzip -o underautomation-fanuc-csharp.zip -d .claude/skills
rm underautomation-fanuc-csharp.zip
```

The same with PowerShell on Windows:

```powershell
Invoke-WebRequest -Uri https://github.com/underautomation/skills/releases/latest/download/underautomation-fanuc-csharp.zip -OutFile underautomation-fanuc-csharp.zip
New-Item -ItemType Directory -Force .claude/skills | Out-Null
Expand-Archive -Path underautomation-fanuc-csharp.zip -DestinationPath .claude/skills -Force
Remove-Item underautomation-fanuc-csharp.zip
```

For the Python skill, replace `csharp` with `python`. For Codex, GitHub Copilot or Cursor, replace `.claude/skills` with `.agents/skills`. If you cannot run commands, give the user the link of the zip and the table of the section "Install manually".

### Step 4: check the installation

1. Check that `SKILL.md` exists in the skills folder, for example `.claude/skills/underautomation-fanuc-csharp/SKILL.md`.
2. Read `sdk-version` under `metadata` in the frontmatter of `SKILL.md`.
3. Read the version of the package installed in the project:
   - C#: `dotnet list package`, line `UnderAutomation.Fanuc`, column `Resolved`;
   - Python: `pip show UnderAutomation.Fanuc`, line `Version`, in the virtual environment of the project when there is one.
4. Tell the user: the skill installed, its folder, the SDK version it documents, and the version of the package. If the versions differ, or if the package is not installed, say it and give the command that installs the documented version: `dotnet add package UnderAutomation.Fanuc --version <sdk-version>` or `pip install UnderAutomation.Fanuc==<sdk-version>`. Do not install or update the package yourself.

If the agent does not list the new skill, tell the user to start a new session in the project.

## What to read next

- [Get started with .NET](/fanuc/documentation/get-started-net) and [Get started with Python](/fanuc/documentation/get-started-python): install the SDK and write a first program.
- [Connect to your robot](/fanuc/documentation/connect): the protocols, their setup on the controller, the connection parameters.
- [underautomation/skills](https://github.com/underautomation/skills): the repository of the skills, and its issues to report a wrong answer of the skill.