# Set Up potato-skill in Claude Code

Source: https://www.potatoannotator.com/docs/getting-started/potato-skill-claude-code

**Claude Code installs potato-skill as a plugin, with `/plugin marketplace add davidjurgens/potato-skill` followed by `/plugin install potato-skill@potato`. The plugin adds one skill, with no agents, hooks, or MCP servers, and Claude loads the skill whenever a request is about building or running an annotation study.** potato-skill was written for Claude Code, and this route gets every part of the skill as designed. [Quick Start with a Coding Agent](/docs/getting-started/quick-start-with-a-coding-agent) covers what the skill does with a study, and [Install potato-skill in Your Coding Agent](/docs/getting-started/install-potato-skill) covers the other agents.

## Before you install

Potato goes in the Python environment that Claude Code's shell uses. The skill's helper scripts import Potato's registries and call the `potato` command, and the skill's first step checks that Potato imports. The browser extra and Chromium let `potato preview --screenshot` and the skill's walk-through script open the task in a headless browser:

```bash
pip install 'potato-annotation[preview]'
playwright install chromium
```

## Installing the plugin

In a Claude Code session, add the marketplace and then install the plugin:

```text
/plugin marketplace add davidjurgens/potato-skill
/plugin install potato-skill@potato
```

The install command opens the plugin's details in the `/plugin` panel and asks for a scope:

| Scope | Who gets the skill | Where Claude Code records the plugin |
|---|---|---|
| User | you, in every project on this machine | `~/.claude/settings.json` |
| Project | everyone who works in the repository | `.claude/settings.json`, which you commit |
| Local | you, in this repository only | `.claude/settings.local.json` |

User scope suits a researcher who builds studies in several project folders. Project scope suits a lab whose studies share one repository. Committing `.claude/settings.json` turns the plugin on for collaborators but does not download the plugin to their machines. Each collaborator runs the install once:

```bash
claude plugin install potato-skill@potato --scope project
```

A setup script can run the same two steps from your shell without opening a session:

```bash
claude plugin marketplace add davidjurgens/potato-skill
claude plugin install potato-skill@potato
```

A plugin installed from the shell loads the next time Claude Code starts, or after `/reload-plugins` in a session that is already open. The terminal, the desktop app's local sessions, and the VS Code extension on one computer read the same settings files. A user-scope install in any one of the three reaches the other two.

## Checking the install

`claude plugin list` in your shell prints the plugin with the plugin's version, scope, and status:

```text
  ❯ potato-skill@potato
    Version: 1.2.0
    Scope: user
    Status: ✔ enabled
```

`claude plugin details potato-skill` lists one skill and no agents, hooks, or MCP servers. The same command estimates the skill's context cost at about 220 tokens in every session, for the skill's name and description, and about 10,900 tokens each time the skill loads.

## Starting a study

Describe the study in plain language. Claude loads the skill without a command when a request matches the skill's description, such as a request to build an annotation task, edit a Potato `config.yaml`, or check on a running study:

> I want 200 tweets labeled for sentiment on a 5-point scale by three annotators each, with a consent page and two attention checks. Build it and start it.

Plugin skills are named after their plugin. Typing `/potato-skill:potato-skill` before the request loads the skill directly. Typing `/` shows the name in the command menu, and `/skills` lists every skill Claude Code has loaded.

## Approving the commands the skill runs

The skill asks Claude to validate the config, start a Potato server, open the task in a headless browser, and run the skill's helper scripts. Each of those is a shell command. In the default Manual mode, Claude Code asks before running a shell command, and answering "Yes, and don't ask again" saves a rule for that command in that repository.

A study build runs `potato validate` and `potato preview` many times. Allow rules in `.claude/settings.json` approve those two commands in advance and leave everything else to a prompt:

```json
{
  "permissions": {
    "allow": [
      "Bash(potato validate *)",
      "Bash(potato preview *)"
    ]
  }
}
```

`/permissions` shows every rule and the settings file each one comes from. potato-skill declares no `allowed-tools`. Every command the skill asks for goes through your permission settings. Claude Code's [permissions documentation](https://code.claude.com/docs/en/permissions) describes the rule syntax and the other permission modes.

## Installing without the plugin system

The `skills` CLI puts the same files in `.claude/skills/potato-skill/` in your project, where Claude Code reads project skills:

```bash
npx skills add davidjurgens/potato-skill --agent claude-code
```

A project skill is named without a plugin prefix, so `/potato-skill` loads the skill. Committing `.claude/skills/` gives collaborators the skill with no install step. Cursor, GitHub Copilot in VS Code, and OpenCode also read `.claude/skills/`. The CLI needs Node.js 22.20 or later. Cloud sessions of Claude Code do not load plugins installed on your own machine. The browser at claude.ai/code runs cloud sessions.

## Updating and removing the plugin

Claude Code updates a plugin automatically only when the plugin's marketplace has auto-update turned on, and auto-update starts off for a marketplace added by hand, such as `davidjurgens/potato-skill`. Update the plugin from your shell:

```bash
claude plugin update potato-skill@potato
```

To update automatically instead, run `/plugin`, open the **Marketplaces** tab, select `potato`, and choose **Enable auto-update**. A running session keeps the version the session loaded, and the next session loads the new one.

`claude plugin uninstall potato-skill@potato` removes the plugin. `/plugin marketplace remove potato` removes the marketplace and every plugin installed from the marketplace. Claude Code's [plugin documentation](https://code.claude.com/docs/en/discover-plugins) covers the `/plugin` panel in full.

## Further reading

- [Quick Start with a Coding Agent](/docs/getting-started/quick-start-with-a-coding-agent)
- [Building an Annotation Study with Claude Code, Codex, or Cursor](/blog/potato-skill-claude-code-annotation-studies)
- [Set Up potato-skill in Codex](/docs/getting-started/potato-skill-codex)
- [Set Up potato-skill in Cursor](/docs/getting-started/potato-skill-cursor)
- [Configs your coding agent can check](/docs/guides/configs-your-coding-agent-can-check)