Habilidades

Skills are instruction packages that teach AI coding agents how to build UiPath automations with uip. They are not tools. Tools extend the CLI with new commands; skills extend a coding agent with UiPath-specific knowledge. A developer types uip or jobs start; a coding agent that has a skill installed knows when to reach for that command, what inputs it needs, and how to sequence it with uip solution pack, uip or packages upload, and the rest.

What is a skill

A skill is a bundle of Markdown files — instructions, examples, decision rules — that an agent reads alongside your conversation to decide how to accomplish a UiPath task. The bundle covers patterns like "how to pack and deploy a Studio project", "how to run a test set in CI", or "how to configure an Orchestrator trigger from the command line". The agent uses the skill the same way a developer would use documentation, except the skill is narrowly scoped to the tasks the skill author considered relevant.

UiPath publishes a skill catalog on GitHub. uip skills install downloads the whole catalog and installs it into the agents you choose.

Supported agents

The following coding agents are supported today:

Agente	Flag value	Install location
Claude Code (plugin)	claude	Managed by the Claude Code plugin system — global only
Cursor	cursor	~/.cursor/skills/<skill>/ (global) or ./.cursor/skills/<skill>/ (local)
GitHub Copilot	copilot	~/.github/skills/<skill>/ (global) or ./.github/skills/<skill>/ (local)
Gemini CLI	gemini	~/.gemini/skills/<skill>/ (global) or ./.gemini/skills/<skill>/ (local)
Codex	codex	~/.agents/skills/<skill>/ (global) or ./.agents/skills/<skill>/ (local) — the open Agent Skills standard directory
OpenCode	opencode	~/.config/opencode/skills/<skill>/ (global) or ./.opencode/skills/<skill>/ (local)

Exact destinations are printed by uip skills install --agent <name> before any files are written. Run uip skills --help to see the live table for your installation.

Granularity: agents, not skills

uip skills install is all-or-nothing on the skill catalog. You pick one or more agents, and the CLI installs every skill UiPath currently publishes into each of those agents. You do not pick individual skills.

Why: the skill set is small enough that cherry-picking would produce more inconsistency than benefit, and the agent itself decides which skill applies to a given task based on its own reasoning — the skill catalog is effectively a reference the agent consults when a task is UiPath-related. Providing the agent with extra skills it will not use has low overhead.

What you do pick:

• Which agents (via --agent <name>, or interactively from a checkbox when the flag is omitted — multi-select).
• Global or local scope (via --local, where the agent supports it).

Global versus local installs

Two scopes:

• Global (default) — skills are installed once per user, on the user's agent profile. Available in every project on that machine.
• Local (--local) — skills are installed into the current directory. Tracked alongside the project; available only when the agent is running in that directory.

Use local for a project that pins skills to a specific UiPath CLI version, or for a repo where a specific set of skills should ship to every contributor regardless of what they have installed globally.

Observação:

Not every agent supports --local. Claude Code is global-only (the Claude Code plugin system is user-scoped); running uip skills install --agent claude --local produces a ValidationError. The other five agents support both scopes.

When you run uip skills install --local, the CLI also adds the on-disk store (.uipath/.skills/, under the walk-up root) to .gitignore so cached skill bundles are not committed.

Installing, updating, uninstalling

Three commands manage the lifecycle:

uip skills install --agent claude                 # install globally for Claude Code
uip skills install --agent cursor --local         # install into this project for Cursor
uip skills install                                # interactive: pick agents from a checkbox
uip skills update --agent claude                  # re-fetch and reinstall
uip skills uninstall --agent claude               # remove skills for Claude Code only

All three prompt for the target agent interactively when --agent is omitted, which is convenient at a workstation and a problem in CI — always pass the flag in pipelines.

update also removes skills that have been dropped from the remote catalog since your last install, so an installed agent tracks the catalog as it evolves. Per-agent skill files are written or overwritten on install and update.

How the agent uses the skills

Once installed, each agent reads skill files through its own mechanism:

• Claude Code loads skills via the plugin system — they become tool-use plugins the agent can invoke.
• Cursor, Gemini CLI, Codex, OpenCode load skill Markdown as context rules attached to every conversation.
• GitHub Copilot reads skills from its user-rules directory.

From the developer's perspective, the difference is invisible. You ask the agent "pack and deploy this project", and if a skill covers it, the agent follows the recipe — calling uip solution pack, uip solution publish, uip solution deploy run in order, handling flag selection, and reporting back.

What skills are not

• Skills do not replace documentation. They distill task-oriented recipes; the full reference lives in the uip docs (this site). An agent with skills still benefits from reading per-command reference pages.
• Skills do not give the agent access to your UiPath tenant. They instruct the agent how to use uip; actual authentication happens via uip login on your machine the same as when you run commands yourself.
• Skills are not tools. uip tools and uip skills are distinct command groups. Tools ship commands; skills teach agents how to use them.
• Skills are not Model Context Protocol (MCP) servers. uip mcp exposes a separate MCP surface for MCP-aware clients. The skills system is the primary AI integration path in 1.x; MCP is available for specialized setups but is not the primary integration.

What to read next

• Using UiPath CLI with coding agents — walkthroughs for setting up each agent, verifying the install, and running a task end-to-end.
• uip skills reference — flags, exit codes, and full examples.
• Managing tools and skills — day-to-day lifecycle, pinning, auditing what is installed.
• Tools (plugins) — the other extension mechanism; explains the distinction between "tools" and "skills".