From e897904899f77df6e99441375daf3fd6bef96e67 Mon Sep 17 00:00:00 2001 From: rockymadden Date: Wed, 2 Sep 2026 07:35:02 -0600 Subject: [PATCH 1/2] feat(uipath-maestro-flow): add reasoning-budget / working-style preamble Ports the preamble uipath-maestro-bpmn has carried since #2622, adapted to Flow: bpmn's "run the shipped script" becomes "run the `uip` verb", since the mechanical work here is `node configure`, `format`, and `registry get` rather than bundled scripts. Deep reasoning is pointed at the judgments no verb can make (node-type selection, topology, cross-node data flow). Where a numbered rule already owns the specifics, the bullet defers to it (#1 output filters, #9 CLI vs ad-hoc scripting, #10 three-turn batching) rather than restating them. Terse mode per .claude/rules/token-optimization.md; +15 lines, ~500 tokens on the always-loaded file. Co-Authored-By: Claude Opus 5 (1M context) --- skills/uipath-maestro-flow/SKILL.md | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/skills/uipath-maestro-flow/SKILL.md b/skills/uipath-maestro-flow/SKILL.md index a298925275..e4fa69b694 100644 --- a/skills/uipath-maestro-flow/SKILL.md +++ b/skills/uipath-maestro-flow/SKILL.md @@ -4,6 +4,21 @@ description: "TRIGGER for `.flow` files, UiPath Flow / Maestro Flow build or edi allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion --- +# Reasoning budget + +- Match reasoning to step difficulty; bias toward acting. For mechanical / IO / format steps, if a `uip` verb covers the task, run it — never hand-derive what the CLI emits (`node configure` detail and `bindings[]`, `format` layout, `registry get` node shapes). +- Save deep reasoning for the judgments no verb can make for you: node-type selection (the external-service ladder), topology, and how data moves from one node's output into the next node's input. + +# Working style + +- **Understand first, then decide.** Read this file and the capability index for the work at hand, then plan against what the CLI verbs do — not a guess. `uip maestro flow --help` and `registry get ` are ground truth for flags and node shapes. +- **Plan the whole path up front, then chain.** Outline the sequence before running anything, batch independent steps into one turn, pipeline the rest. A greenfield build is three turns (rule #10), not ten. +- **Inspect an input ONCE.** To learn a shape — a node type's schema, a connector's fields, an existing `.flow`'s nodes — dump it once and search that output. Never re-read a file field-by-field or re-query the registry once per field. +- **Don't repeat work.** Never rerun a command whose inputs and relevant state are unchanged, or re-read an unchanged file already in context. After a command may have rewritten a file (`node configure`, `format`), re-read it before relying on its contents. +- **Prefer the CLI to ad-hoc code.** Scripting languages are a last resort for `.flow` edits and need user approval first (rule #9). When code is warranted, write it once with paths as arguments; no near-duplicate inline snippets across turns. +- **Keep outputs small.** Extract with `--output json --output-filter` (rule #1) so a large envelope never lands in context whole. When a payload must be kept, write it to a file and inspect the file. +- **Don't do anything unnecessary.** No tool call, file read, or result pulled into context before it is needed. + # UiPath Flow Skill Comprehensive guide for creating, editing, validating, debugging, publishing, diagnosing, and evaluating UiPath Flow projects using the `uip` CLI and `.flow` file format. The skill is organized into four capabilities — **Author**, **Operate**, **Diagnose**, **Evaluate** — each with its own index doc. From 776bbd1fbf4d99556d8b5f3e280c095bc3f5f89f Mon Sep 17 00:00:00 2001 From: rockymadden Date: Wed, 2 Sep 2026 07:41:18 -0600 Subject: [PATCH 2/2] fix(uipath-maestro-flow): make preamble commands runnable, name capture candidates Three review points: - `registry get ` is not a runnable command. Fully qualify it as `uip maestro flow registry get `, since that clause is presented as the ground truth to go run. The checker only scans fenced blocks, so inline prose does not catch this. - Drop the duplicated "three turns, not ten" count from the chaining bullet; rule #10 owns that number. Cite the rule instead. - Name the payloads worth capturing (`flow debug`, `job traces`, `registry get`) and show the redirect, outside the solution tree. Filtering covers "I know the fields"; capture covers "slow, side-effecting, or unrepeatable", so re-reading never means re-running. Co-Authored-By: Claude Opus 5 (1M context) --- skills/uipath-maestro-flow/SKILL.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/skills/uipath-maestro-flow/SKILL.md b/skills/uipath-maestro-flow/SKILL.md index e4fa69b694..a050a360ea 100644 --- a/skills/uipath-maestro-flow/SKILL.md +++ b/skills/uipath-maestro-flow/SKILL.md @@ -11,12 +11,12 @@ allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion # Working style -- **Understand first, then decide.** Read this file and the capability index for the work at hand, then plan against what the CLI verbs do — not a guess. `uip maestro flow --help` and `registry get ` are ground truth for flags and node shapes. -- **Plan the whole path up front, then chain.** Outline the sequence before running anything, batch independent steps into one turn, pipeline the rest. A greenfield build is three turns (rule #10), not ten. +- **Understand first, then decide.** Read this file and the capability index for the work at hand, then plan against what the CLI verbs do — not a guess. `uip maestro flow --help` and `uip maestro flow registry get ` are ground truth for flags and node shapes. +- **Plan the whole path up front, then chain.** Outline the sequence before running anything, batch independent steps into one turn, pipeline the rest (rule #10). Do not run turn-by-turn what could have been chained. - **Inspect an input ONCE.** To learn a shape — a node type's schema, a connector's fields, an existing `.flow`'s nodes — dump it once and search that output. Never re-read a file field-by-field or re-query the registry once per field. - **Don't repeat work.** Never rerun a command whose inputs and relevant state are unchanged, or re-read an unchanged file already in context. After a command may have rewritten a file (`node configure`, `format`), re-read it before relying on its contents. - **Prefer the CLI to ad-hoc code.** Scripting languages are a last resort for `.flow` edits and need user approval first (rule #9). When code is warranted, write it once with paths as arguments; no near-duplicate inline snippets across turns. -- **Keep outputs small.** Extract with `--output json --output-filter` (rule #1) so a large envelope never lands in context whole. When a payload must be kept, write it to a file and inspect the file. +- **Keep outputs small.** Extract with `--output json --output-filter` when you know the fields (rule #1). When the payload is large or the command is slow or side-effecting — `flow debug`, `job traces`, `registry get` — redirect the whole envelope to a file outside the solution tree (`uip maestro flow debug --output json > /tmp/flow-debug.json`) and search the file, so re-reading it never means re-running the command. - **Don't do anything unnecessary.** No tool call, file read, or result pulled into context before it is needed. # UiPath Flow Skill