UiPath + Claude Code: Complete Integration Guide

Chapter 1: Why This Integration Changes How You Build Automations

If you have ever spent an afternoon writing boilerplate XAML, hunting for the right selector, or manually wiring up exception handling blocks — you already know how much of RPA development is repetitive scaffolding rather than actual problem-solving. That is exactly the gap this integration fills.

UiPath and Claude Code, when wired together through the UiPath CLI and Skills layer, give you a conversational coding partner that understands your automation requirements and generates production-ready workflows, complete with retry logic, error handling, and credential management.

This guide walks through the complete setup from scratch: installing the CLI, authenticating, installing Skills, and building a real automation using both available methods. By the end, you will have a working ACME System login workflow and a clear mental model of how the two tools interact at every step.

What You Will Learn

• How UiPath CLI, Skills, and Claude Code fit together (and why CLI is the foundation)
• Method 1: Building automations through Claude Code’s chat interface
• Method 2: Building automations through UiPath Studio’s integrated terminal
• All 23 Skills explained — when to use each one
• A complete end-to-end example: ACME System login with exception handling
• Troubleshooting the most common errors

Chapter 2: Understanding the Architecture

Before running any commands it is worth understanding how the pieces connect. There are four layers involved: your automation code at the top, Skills in the middle, the CLI underneath, and the UiPath Platform at the base. Each layer depends on the one below it.

Technology Stack — Dependency Chain

Layer	Component	Role & Functionality
Layer 4	Your Automation Code	XAML files, project.json configurations, and supporting assets generated by Skills.
Layer 3	UiPath Skills	23 Markdown-based AI instruction bundles injected into Claude’s prompt context.
Layer 2	UiPath CLI (uip)	Runtime engine handling authentication, token storage, packaging, and skill execution.
Layer 1	UiPath Platform	Orchestrator for scheduling, Studio for design, and Robot runtime for execution.

The Four Layers Explained

Layer 1 — UiPath Platform: This is the foundation: Orchestrator for scheduling and monitoring, Studio for visual design, and the Robot runtime for execution. You must have an account and at minimum a Community license to authenticate.

Layer 2 — UiPath CLI (uip): The CLI is the bridge between your local machine and the UiPath Platform. It handles authentication, project packaging, job triggering, and — critically — it is the runtime host for Skills. Without the CLI installed, Skills have nothing to run on. Think of it as the engine that Skills plug into.

Layer 3 — UiPath Skills: Skills are Markdown-based instruction bundles that extend Claude’s knowledge of UiPath-specific tasks. When you ask Claude to ‘create a retry scope’ or ‘add credential lookup,’ Skills tell Claude exactly which UiPath activities to use, how to structure the XAML, and which project settings to apply.

Layer 4 — Your Automation Code: This is what you are actually building: XAML workflow files, project.json configurations, and supporting assets. Skills generate this code; the CLI packages and deploys it; the Platform runs it.

CLI vs Skills — A Common Point of Confusion

Developers often ask whether they really need the CLI if they already have Skills. The short answer is yes, always. Here is why:

• Skills are installed by CLI: the command uip skills install –agent claude writes the instruction files that Claude reads
• Skills call CLI commands internally: when a Skill generates code that authenticates or packages a project, it calls uip underneath
• Authentication lives in CLI: the token stored by uip auth login is what Skills use when they communicate with Orchestrator
• Remove CLI and the entire stack loses both its installer and its runtime host.

Chapter 3: Prerequisites and Installation

This chapter covers the complete installation sequence. Follow these steps in order — skipping ahead will result in errors that are harder to debug than the installation itself.

3.1 System Requirements

• Node.js 18 or later (check with: node –version)
• .NET 6 SDK (required for Windows-target projects)
• UiPath Studio 2023.10 or later
• Active UiPath account (Community license is fine)
• Git (optional but recommended)

3.2 Install Node.js

If you do not have Node.js, download the LTS version from nodejs.org. After installation, verify it works:

node –version npm –version

3.3 Install the UiPath CLI

Install the CLI globally so the uip command is available from any directory:

npm install -g @uipath/cli

After installation, confirm it is working:

uip –version # Expected output: 1.197.1 (or newer)

ℹ  Windows PATH Configuration: On Windows, global npm packages go to %APPDATA%\npm. If the uip command is not found after installation, add that folder to your PATH environment variable and restart your terminal.

3.4 Authenticate with the UiPath Platform

This step connects your local machine to your UiPath account. The CLI stores an OAuth token locally so all subsequent operations are authorized:

uip auth login

Your browser opens to a UiPath login page. After you sign in, the terminal shows:

Successfully authenticated as: your.email@domain.com Token stored locally.

To verify authentication status at any time:

uip auth status

3.5 Install UiPath Skills

Now install the 23 Skills into Claude’s agent context. This is what gives Claude its UiPath-specific knowledge:

uip skills install –agent claude

The command downloads and installs all 23 skills. You should see output similar to:

Installing UiPath Skills for Claude… Package: uipath@uipath-marketplace v1.197.2 ✓ create-project ✓ generate-workflow ✓ add-activity … (20 more skills) All 23 skills installed successfully.

To list all installed skills:

uip skills list

Chapter 4: The 23 UiPath Skills — Complete Reference

Skills are the intelligence layer of this integration. Each skill is a focused instruction set that tells Claude how to generate correct UiPath code for a specific task.

The 23 UiPath Skills — Organized by Category

Category	Skills Included	What It Does
RPA Development	create-project, generate-workflow, add-activity	Builds XAML automation workflows
Solution Design	design-solution, analyze-requirements	Translates requirements to architecture
Agentic AI	create-agent, design-agent-workflow	Builds AI-driven UiPath agents
Testing	create-test-case, generate-test-data	Generates test cases and data
Code Review	review-code, suggest-improvements	AI code quality analysis
Documentation	generate-docs, create-readme	Auto-generates project docs
Orchestration	configure-orchestrator, setup-triggers	Platform and robot configuration

Key Skills in Detail

create-project: Scaffolds a new UiPath project with the correct project.json structure, including the right targetFramework, modernBehavior flag, and empty dependencies object. Use this at the start of any new automation.

# Example prompt: “Create a new UiPath Windows project called ACME_Login” # Generated project.json includes: {   “targetFramework”: “Windows”,   “modernBehavior”: true,   “dependencies”: {} }

generate-workflow: Creates a complete XAML workflow file for a given automation task. Handles namespace declarations, activity sequences, and variable scoping. The most frequently used skill.

add-activity: Inserts a specific UiPath activity into an existing workflow at the right position, with correct argument binding. Works with all Modern Activities.

create-agent: Builds an agentic automation that can make decisions, loop based on conditions, and interact with AI services. Essential for AI-assisted workflows.

create-test-case: Generates a complete test case for an existing workflow, including input data, expected outputs, and assertion activities. Integrates with UiPath Test Suite.

Step-by-Step Workflow for Method 1

Step 1: Open Claude Code — Launch Claude Code from your terminal or IDE extension:

claude

Step 2: Confirm Skills Are Active — Ask Claude to verify the available UiPath skills:

“List the UiPath skills you have available”

Step 3: Create Your Project — Tell Claude what project you want to scaffold:

“Create a new UiPath Windows project called ACME_Login. The goal is to log into https://acme-test.uipath.com using stored credentials, with retry logic and exception handling.”

Step 4: Build the Login Workflow — Ask Claude to generate the core login logic:

“Generate a Login.xaml workflow that:  – Reads credentials from Windows Credential Manager  – Opens Chrome and navigates to the ACME site  – Retries the login up to 3 times with a 5-second interval  – Throws a BusinessRuleException if login fails after retries  – Returns a Boolean out_IsLoggedIn argument”

Step 5: Add Exception Handling — Request structured exception handling:

“Add a dual TryCatch to Login.xaml:  – Inner catch: BusinessRuleException → Log Warning + Rethrow  – Outer catch: System.Exception → Take Screenshot + Log Error + Rethrow”

Step 6: Run and Verify — Execute the generated workflow:

uip run –project ACME_Login –workflow Main.xaml

Chapter 6: Method 2 — Building Automations in UiPath Studio Terminal

Method 2 works inside UiPath Studio’s integrated terminal using slash commands. This approach is ideal when you already have an open project and want AI assistance without leaving Studio.

Step-by-Step Workflow for Method 2

Step 1: Open UiPath Studio — Launch Studio 2023.10+ and open an existing project.

Step 2: Open the Integrated Terminal — Go to View → Terminal, or press Ctrl+` (backtick).

Step 3: Verify Slash Commands — Type /uipath help in the terminal panel.

Step 4: Generate Workflow Using Slash Commands — Issue commands directly into your project workspace:

/uipath generate-workflow “Login to ACME system with retry and exception handling” /uipath add-activity “Add email validation before login attempt” /uipath create-test-case “Test ACME login with valid and invalid credentials”

Complete Slash Command Reference

• /uipath create-project: Scaffolds a new project in the current directory
• /uipath generate-workflow: Creates a XAML workflow from a description
• /uipath add-activity: Adds an activity to an open workflow
• /uipath design-solution: Breaks requirements into workflow architecture
• /uipath create-agent: Builds an agentic automation
• /uipath create-test-case: Generates a test case for a workflow
• /uipath review-code: AI review of open workflow for issues
• /uipath generate-docs: Auto-generates documentation
• /uipath configure-orchestrator: Generates Orchestrator config YAML

Chapter 7: End-to-End Example — ACME System Login

This chapter builds a complete, production-ready automation from scratch. The automation logs into the ACME Test System, handles errors gracefully, and follows all RPA best practices.

7.1 Project Structure

ACME_Login/ ├── project.json         (project metadata + settings) ├── Main.xaml            (entry point — calls Login) └── Workflows/     └── Login.xaml       (all login logic lives here)

7.2 project.json

{   “name”: “ACME_Login”,   “description”: “Logs into ACME Test System with retry and exception handling”,   “main”: “Main.xaml”,   “outputType”: “Process”,   “targetFramework”: “Windows”,   “modernBehavior”: true,   “dependencies”: {},   “designOptions”: {     “modernBehavior”: true   } }

ℹ  Critical Setting Warning: “dependencies” must be an empty object {}. Adding packages here without pinning exact versions causes Studio to fail package resolution.

7.3 Login.xaml Key Code Sections

Credential Retrieval:

<uia:GetSecureCredential   Target=”Windows Credential Manager”   Identifier=”ACME_Credentials”   UserName=”{x:Null}”   Password=”{x:Null}”   Result=”[v_Credential]” />

SecureString Password Pattern:

UiPath’s TypeInto for password fields requires converting SecureString. The correct pattern is:

New Net.NetworkCredential(String.Empty, v_SecurePassword).Password

Dual TryCatch Exception Architecture:

<!– Outer catch: System.Exception –> <catch:Catch TypeName=”System.Exception”>   <uia:TakeScreenshot />   <log:LogMessage Level=”Error” Message=”System error: ” + ex.Message />   <rethrow:Rethrow /> </catch:Catch> <!– Inner catch: BusinessRuleException –> <catch:Catch TypeName=”UiPath.Core.BusinessRuleException”>   <log:LogMessage Level=”Warn” Message=”Business rule: ” + ex.Message />   <rethrow:Rethrow /> </catch:Catch>

Chapter 8: Authentication and Security

Authentication is one area where developers often get tripped up. This chapter explains how credentials flow through the system.

8.1 CLI Authentication Flow

• Opens your browser to UiPath’s OAuth 2.0 authorization endpoint
• Receives an authorization code after you sign in
• Exchanges it for an access token + refresh token
• Stores the tokens encrypted in the local credential store
• All subsequent uip commands read the stored token automatically

8.2 Managing Multiple Tenants

# Add a second account uip auth login –profile production # Switch active profile uip auth set-active production # List all profiles uip auth list

8.3 Handling Credentials Safely

• Windows Credential Manager — GetSecureCredential activity for local development
• UiPath Orchestrator Assets — for robot-level or process-level credentials
• Azure Key Vault integration — for enterprise deployments

ℹ  Security Rule: The SecureString returned by GetSecureCredential should never be converted to plain string except at the exact point of use (TypeInto). Pass SecureString variables through the workflow and only call NetworkCredential conversion inside SecureText.

Chapter 9: Packaging and Deploying to Orchestrator

Building the workflow is only part of the job. This chapter covers packaging your automation and deploying it to Orchestrator.

9.1 Package the Project

uip pack –project ACME_Login –output ./packages # Creates: ./packages/ACME_Login.1.0.0.nupkg

9.2 Deploy to Orchestrator

uip deploy –package ./packages/ACME_Login.1.0.0.nupkg \            –orchestrator-url https://cloud.uipath.com \            –tenant MyTenant \            –folder MyFolder

9.3 Trigger a Job

uip start-job –process ACME_Login –folder MyFolder –robot MyRobot

Chapter 10: Troubleshooting Common Issues

Most problems fall into three categories: CLI not found, authentication failures, and workflow generation issues.

Error / Symptom	Root Cause	Fix Path
uip: command not found	CLI not installed globally	npm install -g @uipath/cli
Skills not recognized	Skills not installed into agent	uip skills install –agent claude
401 Unauthorized	Token expired or not authenticated	uip auth login
Module not found: dotnet	.NET SDK missing on workstation	Install .NET 6 SDK from Microsoft
Studio Terminal no /uipath	Skills missing in terminal environment	Run uip skills install –agent claude
XAML validation fails	Wrong .NET target in project.json	Set targetFramework: Windows, modernBehavior: true

Chapter 11: Best Practices for Production Automations

Workflow Structure

• Keep Main.xaml thin — it should only orchestrate calls to sub-workflows
• One logical operation per workflow file (Login, NavigateToReport, ExtractData)
• All input arguments use In_ prefix; output arguments use Out_ prefix
• Boolean result arguments are named IsXxx (IsLoggedIn, IsDataFound)

Error Handling

• Every workflow that touches external systems needs a TryCatch
• BusinessRuleException for expected failures (wrong credentials, item not found)
• System.Exception for unexpected failures (network down, selector broken)
• Always take a screenshot before rethrowing a System.Exception

Credential & Version Control

• Never hardcode passwords in XAML or project.json
• Use Windows Credential Manager for local development and Orchestrator Assets for production
• Add /packages and /.local to .gitignore

Chapter 12: Frequently Asked Questions

Q: Do I need a paid UiPath license to use this integration?
No. The Community license is sufficient. You need an active account for authentication, but the CLI and Skills work fine with Community accounts.

Q: Can I use this with UiPath Studio Web?
The CLI and Skills work with Studio Desktop and Robot runtime. Direct CLI integration with Studio Web is not currently supported.

Q: How do Skills know which version of activities to target?
Skills target the activity packages available in the latest stable UiPath release. The create-project skill sets up project.json without pinned versions by default.

Q: The generated XAML has namespace errors in Studio. How do I fix it?
This almost always means a mismatch between targetFramework in project.json and namespaces in XAML. For Windows (.NET 6), use assembly=System.Private.CoreLib.

Conclusion

The UiPath and Claude Code integration is one of the most practical AI-in-automation tools available. It does not replace your judgment as an RPA developer — you still need to design robust architectures, handle exceptions, and structure workflows cleanly. What it eliminates is the tedious boilerplate scaffolding.

The two-method approach gives you total flexibility: use Method 1 (Claude Code chat) for net-new projects to move fast, and Method 2 (Studio terminal slash commands) when iterating inside existing projects.

ℹ  Quick Start Command: Run: npm install -g @uipath/cli && uip auth login && uip skills install –agent claude — then open Claude Code and start building!