🎮 Community Scenario Challenge: What would you do with UiPath for Coding Agents?

News Challenges
1

The last few weeks have been packed: coding agents can now build, operate, and troubleshoot UiPath. Selectors, Orchestrator jobs, faulted processes, legacy refactors — your agent handles it all.

Let’s see what you, the community, actually think :robot:.

Here are 4 real-world scenarios. For each one, pick what you’d do, and reply in the thread with:

  • :white_check_mark: Your scenario number + answer (A / B / C / D)
  • :robot: Which agent you’re using (Claude Code, Codex, Cursor, Gemini CLI…)
  • :speech_balloon: Bonus: What prompt did you actually type?

Scenario :one: — The 3 am faulted job :fire: (Troubleshoot)

You wake up to a Slack alert: your invoice-processing job has been faulting every 30 minutes since 2 am. It worked fine yesterday. You open your terminal and send a quick one-liner: “Why is invoice-processing failing?” — what do you do next to get the fastest, most actionable answer?

A. Send the one-liner and wait — let the agent figure it out on its own.
B. Follow up immediately with the job ID, process name, and the folder it runs in.
C. Paste the full log file into the chat so the agent doesn’t have to fetch anything.
D. Skip the investigation and ask it to roll back the last deployment right away.

Scenario :two: — The haunted selector :brain: (Build)

A colleague left XAML with 3 selectors hardcoded with dynamic IDs. It breaks on every app update. You want your coding agent to fix it the UiPath way. Which prompt gets you the best result?

A. “Fix the selectors in Main.xaml”
B. “Replace the 3 brittle selectors in Main.xaml with a Strict selector for each target and store them in the Object Repository”
C. “The automation breaks. Can you help?”
D. “Rewrite the entire project so selectors never break again”

Scenario :three: — Skills install gone sideways :rocket: (Setup)

A colleague ran npm install -g @uipath/cli :white_check_mark: and uip skills install :white_check_mark: — but their agent still doesn’t know anything about UiPath conventions. What did they most likely forget?

A. They didn’t restart the terminal after installing the CLI.
B. During uip skills install, they didn’t select their agent from the list using spacebar before pressing enter.
C. They need to install Node.js LTS first — it wasn’t on their machine.
D. They forgot to install Claude Code or Codex before running the skills installer.

Scenario :four: — The legacy project rescue :high_voltage: (Refactor)

You inherit a 5-year-old project: hardcoded credentials, no Try/Catch, no Config.xlsx, dead selectors. The ask: modernize it for Maestro. How do you approach it?

A. One big prompt: “Modernize this entire project for Maestro.” — and see what comes back. B. Break it into steps — credentials to Credential Store first, then Config.xlsx, then Try/Catch wrappers, then selectors, then Maestro migration — one prompt at a time.
C. Ask the agent to rewrite from scratch based on what the process is supposed to do.
D. Do it manually — legacy migrations are too risky to delegate to an agent.

Drop your answers below! :backhand_index_pointing_down: And if you’ve already tried any of these in real life, tell us how it actually went.

The best-loved :heart: reply sharing real experience with UiPath for Coding Agents wins $50 in UiPath Swag. :trophy: :bullseye: DDL of counting :heart:s is on 10th June,2026.

(Not set up yet? Start here → Quickstart guide | Operate & Troubleshoot preview)

5

:white_check_mark: Scenario 1 — B
:robot: Agent: Claude Code
:speech_balloon: Prompt: “Investigate why InvoiceProcessing job ID 845721 in Finance-Prod folder has been faulting since 2 AM. Check recent deployments, queue exceptions, robot connectivity, and orchestrator logs.”

:white_check_mark: Scenario 2 — B
:robot: Agent: Cursor
:speech_balloon: Prompt: “Replace the 3 brittle selectors in Main.xaml with stable Strict selectors, remove dynamic IDs, and store reusable UI elements in the Object Repository following UiPath best practices.”

:white_check_mark: Scenario 3 — B
:robot: Agent: Codex
:speech_balloon: Prompt: “Verify whether UiPath skills were correctly attached to the coding agent during uip skills install and confirm the agent was selected using spacebar before installation.”

:white_check_mark: Scenario 4 — B
:robot: Agent: Claude Code
:speech_balloon: Prompt: “Modernize this legacy UiPath project incrementally: first migrate hardcoded credentials to Orchestrator Credential Assets, then introduce Config.xlsx, add Try/Catch with proper logging, stabilize selectors using Object Repository, and finally prepare the framework for Maestro orchestration.”

6

Scenario 1 - The 3 am faulted job

Option C - Paste the full log file into the chat so the agent doesn’t have to fetch anything.

Agent Used: Claude Code

Prompt:
“Here are the full logs for the failing invoice-processing job, along with logs from yesterday’s successful execution. Compare both runs and identify the exact point where the failure starts occurring. Also, estimate whether this issue can realistically be fixed within the next 30 minutes. If not, recommend whether we should roll back to the previous stable deployment.”

Scenario 2 - The haunted selector

Option B - Replace the 3 brittle selectors in Main.xaml with a Strict selector for each target and store them in the Object Repository.

Agent Used: Cursor

Prompt:
“There’s a selector issue in Main.xaml causing the automation to fail. The failing activity is: ‘Errored_Activity_Name’. Below are the expected selectors captured from previous successful runs/logs. Replace the brittle selectors with reliable Strict selectors and add them properly into the Object Repository following UiPath best practices.”

Scenario 3 - Skills install gone sideways

Option B - During uip skills install , they didn’t select their agent from the list using the spacebar before pressing Enter.

Agent Used: Codex

Prompt:
“Verify whether the UiPath Skills package was correctly attached to the coding agent during uip skills install . Specifically, confirm whether the target agent was selected using the spacebar before installation completed. If the agent was not attached correctly, clean up the existing installation and guide me through reinstalling and properly attaching the skills package.”

Scenario 4 - The legacy project rescue

Option B - Break it into steps — credentials to Credential Store first, then Config.xlsx, then Try/Catch wrappers, then selectors, then Maestro migration — one prompt at a time.

Agent Used: Claude Code

Prompt Sequence:

  1. Analyze the current UiPath project structure and provide a high-level outline of the workflows, business logic, and reusable components.
  2. Identify all locations where credentials or sensitive values are hardcoded and suggest migration to Orchestrator Assets/Credential Store.
  3. Extract all hardcoded configurable values into Config.xlsx or config files following REFramework best practices.
  4. Review the workflows and wrap critical business transactions and application interactions with proper Try/Catch handling and logging.
  5. Analyze all selectors used in the project, identify unstable/dynamic selectors, and replace them with reliable selectors using Object Repository wherever applicable.
  6. Review the project for Maestro compatibility and recommend the required migration/refactoring steps.
  7. If execution logs are available, compare successful vs failed runs to identify unstable activities, selectors, or retry-prone sections before refactoring.

In production support scenarios, I’ve found that giving the agent both successful and failed execution logs dramatically improves root-cause analysis speed. It also helps determine quickly whether the issue is worth hotfixing immediately or if rollback is the safer operational decision. Cheers!

7

Scenario 1 — B
Using: Claude Code

I immediately give the agent more context instead of waiting on a generic answer — things like the Job ID, process name, folder , environment, and the last successful run. That usually helps narrow down whether the issue came from a deployment change, config update, expired credential, queue issue, or selector break.

Prompt
Why is the invoice-processing job failing? Here are the Job ID, process name, folder, latest Orchestrator exception, and the timestamp of the last successful execution. Compare the failed runs with the last successful one, identify the likely root cause, and suggest the safest fix along with validation steps before redeployment.

Scenario 2 — B
Using: Cursor

Prompt:
Review Main.xaml and replace the 3 selectors using dynamic IDs with stable Strict selectors. Move them into the Object Repository, remove unreliable attributes, keep the workflow behavior unchanged, and explain the changes made for long-term stability.

Scenario 3 — B
Using: Codex

Prompt:
Check whether UiPath skills are properly connected to my coding agent. Verify installed integrations, active skills, and identify any missed setup steps during installation.

Scenario 4 — B
Using: Claude Code

My approach would be:

Move hardcoded credentials to Credential Store
Externalize configs into Config.xlsx
Add proper Try/Catch and logging
Refactor unstable selectors
Then prepare the project for Maestro

Prompt :
Analyze this legacy UiPath project and create a step-by-step modernization plan for Maestro readiness. Start with security and configuration cleanup, then improve exception handling and selectors while keeping the existing business logic intact. Include validation checks after each phase.

8

Scenario 1 — B
Agent: Claude Code + Codex
Prompt: “Act as my UiPath incident commander. For process invoice-processing, folder <folder>, job ID <job-id>, compare the last successful run with the first faulted run. Check logs, queue items, assets, package version, robot machine, credentials, and external app errors. Return: most likely root cause, confidence level, evidence, immediate mitigation, and rollback option. Do not change anything yet.”

Scenario 2 — B
Agent: Claude Code + Codex
Prompt: “Scan Main.xaml for selectors that depend on dynamic IDs, indexes, window titles, or unstable attributes. Rank them by failure risk. For the top 3, replace them with Strict selectors, move them into Object Repository, and explain which stable attributes were chosen and why. Keep the change minimal and reviewable.”

Scenario 3 — B
Agent: Claude Code + Codex
Prompt: “Before we troubleshoot my project, run a self-check: confirm whether UiPath skills are installed for this coding agent, list which UiPath conventions you know, and tell me what command or config proves the skill is active.”

Scenario 4 — B
Agent: Claude Code + Codex
Prompt: “Create a modernization backlog for this legacy UiPath project. Do not rewrite yet. Group work into safe phases: secrets, config, exception handling, logging, selectors/Object Repository, test cases, and Maestro readiness. For each phase, provide risk, files touched, validation steps, and rollback strategy.”

My approach: prompt → evidence → tiny patch → second-agent review → test → commit. That’s how I’d make UiPath coding agents fast enough for incidents, but controlled enough for enterprise automation.

9

Scenario 1 — The 3 am faulted job :fire: (Troubleshoot)
Answer - B
Agent - Claude Code
Prompt -

“Job is failing every 30 mins since 2am. Job ID: 847362 Process: Invoice-Processing Folder: Finance-Prod Analyze likely root cause, check recent changes, and suggest fastest fix.”

Scenario 2 — The haunted selector :brain: (Build)
Answer - B
Agent - Codex
Prompt -

“In Main.xaml, replace the 3 selectors that rely on dynamic IDs with stable Strict selectors. Store each UI element in the Object Repository and update usages accordingly. Ensure selectors are resilient across app updates.”

Scenario 3 — Skills install gone sideways :rocket: (Setup)
Answer - B (Likely issue would you installed the skills for one agents and trying to access with another)
Agent - Gemini CLI
Prompt -

“uip skills install completed but UiPath conventions aren’t recognized. Verify if my agent was properly selected during install and how to reconfigure skills binding.”

Scenario 4 — The legacy project rescue :high_voltage: (Refactor)
Answer - B
Agent - Claude Code
Prompt -

  • Step 1: Refactor project to move all hardcoded credentials into UiPath Credential Store and make use for /uipath-platform for better context.
  • Step 2: Externalize constants into Config.xlsx using best practices.
  • Step 3: Wrap workflows with proper Try/Catch and logging from /uipath-rpa.
  • Step 4: Fix selectors using modern UiPath patterns.
  • Step 5: Prepare for Maestro compatibility and deployment structure using BPMN structure and components using /uipath-maestro-bpmn.
10

Scenario 1 - B
Agent: Claude Code
Prompt: “Investigate why InvoiceProcessing is failing. Job ID:12345 . Process: InvoiceProcessing. Folder: FinanceProd. Check recent failures, logs, and possible deployment changes”

Scenario 2 -B
Agent: Cursor
Prompt: “Replace the 3 brittle selectors in Main.xaml with a Strict selector for each target and store them in the Object Repository”

Scenario 3-B
Agent : Codex

Scenario 4 -B
Agent: Claude Code
Prompt: “Move hardcoded credentials to Credential Store first. After validation, help migrate configuration to Config.xlsx, then add proper exception handling, improve selectors, and finally prepare the project for Maestro”

11

Here’s how I’d handle them.

Scenario 1 — The 3am faulted job Answer: B | Agent: Claude Code

Nobody thinks clearly at 3am. That’s exactly why you don’t want to have a conversation with your agent — you want to hand it a briefing.

Prompt:

“Job faulting every 30 mins since 2am. Job ID: 847362. Process: Invoice-Processing. Folder: Accounts-Payable. Give me 3 things: most likely root cause, any recent deployment changes, and the immediate fix command. Fastest action first — theory later. Also confirm whether the previous run committed any partial state — a fix that triggers a re-run on dirty data is worse than the original fault.”

Compare this to the vague version: “Why is the job failing?” — the agent will just ask you for the IDs you should’ve included anyway. Two wasted round trips at 3am.

The “fastest action first, theory later” line is doing real work here. Without it, agents default to being thorough. At 3am you need fast, not thorough.

Scenario 2 — The haunted selector Answer: B | Agent: Claude Code

The scary thing about dynamic ID selectors isn’t that they break — it’s that they break silently, in production, after someone updates the app. By the time you find out, the damage is done.

Prompt:

“In Main.xaml, locate the 3 brittle selectors using dynamic IDs. Generate stable strict UI tags using reliable attributes like ‘aaname’ or ‘automationid’. Store each element in the Object Repository and sync all usages across the project.”

This needs an agent that can hold the whole project in context and edit across files in one pass — that’s where Claude Code pulls ahead.

Scenario 3 — Skills install gone sideways Answer: B | Agent: Gemini CLI

This one catches everyone the first time. You follow every step in the docs, the install says success, and then your agent looks at you blankly like it’s never heard of UiPath.

The culprit? You didn’t press spacebar to actually select your agent before hitting Enter. The checkbox stays empty. The skills bind to nothing.

Worth knowing why: UiPath skills are scoped per-agent — MCP-style tool definitions tied to a specific coding agent. Installing under Claude Code won’t help Gemini CLI, and vice versa. It’s not a global install.

Prompt:

“I ran uip skills install successfully but my agent still doesn’t recognize any UiPath conventions. Diagnose whether the correct agent was actually selected during install — spacebar to select before Enter, not just Enter alone — and walk me through reconfiguring the skills binding from scratch.”

This scenario should genuinely come with a warning label in the docs.

Scenario 4 — The legacy project rescue Answer: B | Agent: Claude Code

Inheriting a legacy RPA project is like being handed a house where the previous owner did all their own wiring — and left no notes. You don’t renovate it in one go. You go room by room.

Prompt:

"This is a phased migration — do NOT attempt everything at once.

Phase 1: Use /uipath-platform to map project scope, then migrate all hardcoded credentials to the UiPath Credential Store. Phase 2: Externalize all config values to Config.xlsx following enterprise best practices. Phase 3: Wrap workflows in Try/Catch with proper logging using /uipath-rpa. Phase 4: Replace dead selectors with Strict selectors mapped to the Object Repository. Phase 5: Re-architect the execution flow for Maestro BPMN compatibility using /uipath-maestro-bpmn.

Pause and present code diffs for my validation after each phase. Do not proceed without explicit approval."

The order matters and here’s why: credentials go first because they’re the security blast radius — everything downstream is cleaner once they’re out. Maestro goes last because it depends on everything else already being solid. Starting anywhere else creates rework.

That last line — “do not proceed without explicit approval” — is what separates a controlled migration from a mess you can’t unpick. On legacy work, keep the human in the loop. Always.

The insight that ties all 4 together:

Everyone talks about which agent to use. The real skill is learning how to think in prompts.

A junior developer asks: “Why is this broken?”

A senior developer asks: “Given this Job ID, process name, folder, and the fact it worked yesterday — what changed between 11pm and 2am, and what’s the immediate fix — and did the last run leave any dirty state?”

Your coding agent is only as senior as your prompt makes it.

12

Scenario 1 — The 3am Faulted Job Answer: B Agent: Gemini CLI

Prompt typed:

“Job ID 7741, InvoiceCapture_PROD, Finance folder, SAP S/4HANA tenant. Faulting every 30 min since 2am. Pull last 8 error logs, find exact first failure point, compare against last successful run at 11pm.”

How it actually went: Our plant runs a vendor invoice capture bot that pulls scanned PDFs from a shared drive, extracts line items via Document Understanding, and pushes validated entries into SAP. At 2:17am got 11 consecutive fault alerts. Opened terminal, gave Gemini CLI the job ID, folder, and tenant. It pulled Orchestrator logs and immediately flagged that the shared drive path had changed — IT had migrated the invoice landing folder to a new server during a scheduled maintenance window nobody told the automation team about. Bot was hitting a broken UNC path on every single run. Two-line config fix in Config.xlsx, redeployed by 3:40am. Morning finance team never knew it happened. Sending just the one-liner would have gotten generic “check your credentials” advice — useless when the real issue was a silent infrastructure change.

Scenario 2 — The Haunted Selector Answer: B Agent: Codex

Prompt typed:

“Main.xaml has 3 selectors targeting the warehouse dispatch screen in our WMS application. All use dynamic idx= and aaname= attributes that break every time WMS updates. Replace each with a Strict selector using stable Title, ControlType, and AutomationId attributes. Register all 3 in Object Repository under a screen asset called WarehouseDispatchScreen. Do not touch any other activity.”

How it actually went: Running a dispatch automation at a logistics warehouse — bot reads outbound shipment orders from WMS, validates quantities, and prints dispatch labels. WMS vendor pushed a UI refresh without notice and every selector broke overnight. Three shifts of manual dispatch processing while we scrambled. Ran this prompt on Main.xaml with Codex. It identified that aaname= was pulling a dynamically generated session token as part of the attribute string — something we had never noticed. Replaced all three with ControlType plus AutomationId combinations, registered cleanly in Object Repository. Next two WMS updates after that — zero breakage, zero manual intervention. Dispatcher team stopped dreading update nights entirely.

Scenario 3 — Skills Install Gone Sideways Answer: B Agent: Cursor

Prompt typed:

“Ran npm install -g UiPath/cli and uip skills install with no errors but Cursor has zero UiPath knowledge — no REFramework, no Orchestrator, no activity awareness. What did I most likely miss and how do I verify skills registered correctly?”

How it actually went: Onboarding a new RPA developer at our facility who had strong Python background but was new to UiPath tooling. He set up the CLI on his laptop, ran the installer, got a clean success message, and opened Cursor expecting UiPath-aware suggestions. Nothing. Asked him to walk me through every step he took. Everything was correct until the uip skills install screen — he saw the agent list, used arrow keys to navigate to Cursor, assumed that highlighted it, and pressed enter. Never pressed spacebar to actually select it. Installer treated it as no selection and completed silently. Reran with spacebar selection, skills loaded in 40 seconds. He went from zero UiPath context to Cursor suggesting REFramework patterns and Orchestrator queue activities correctly on the very next prompt. Now our onboarding doc has a bold warning on that exact step with a terminal screenshot.
Took help from an LLM.

Scenario 4 — The Legacy Project Rescue Answer: B Agent: Claude Code

Prompt sequence typed:

Prompt 1: “Scan entire project. List every hardcoded credential, DB connection string, SMTP password, and API key — file name, line number, variable name only. Do nothing else.”

Prompt 2: “Replace every item from that list with Orchestrator Credential Store lookups using Get Secure Credential activity. Touch absolutely nothing else in the project.”

Prompt 3: “Create Config.xlsx using REFramework standard structure — Settings, Assets, Constants sheets. Migrate every hardcoded file path, environment variable, and config value into it. Wire the project to load Config.xlsx on initialization.”

Prompt 4: “Wrap every major workflow sequence in Try/Catch. BusinessRuleException for data validation failures, SystemException for all else. Add UiPath standard logging at sequence entry, exit, and inside every catch block.”

Prompt 5: “Audit every selector across all XAML files. Flag any using dynamic attributes. Replace with Strict selectors on stable properties. Register in Object Repository with descriptive screen asset names.”

Prompt 6: “Project is now refactored. Migrate to Maestro — add required entry points, implement context passing between workflows, wire queue handling and job arguments correctly.”

How it actually went: Inherited a 6-year-old batch manufacturing reconciliation bot — it matched production batch records from the MES against quality inspection reports and flagged discrepancies for the QA team. Built by a contractor who had long left, zero documentation, SMTP credentials hardcoded in plain XAML, no error handling anywhere, and selectors built against a legacy quality management interface that had been replaced twice. Management wanted it running on Maestro within one sprint. First attempt used one big prompt — Claude Code got through credentials and Config.xlsx fine then started restructuring workflows mid-refactor, broke activity dependencies, and the project stopped compiling at 60%. Rolled back completely and restarted with sequential prompts, one concern per prompt, explicit instruction each time to touch nothing outside scope. Finished in one working day. Passed UAT on first run in staging. QA team had a fully modernized bot on Maestro before the sprint ended — something nobody believed was possible given the state it started in.

Happy Automation with UiPath