Skip to content

trevhud/rote / plugin/skills/setup

Walk the user through rote's first run: import the MCP servers they already use, compile one of their skills, and show that the compiled skill gives the same answer, faster and cheaper. Use when the user says "set up rote", "get started with rote", "try rote on my skills", "onboard me", or just installed rote and asks what to do first.

FileKindSize
SKILL.mdskill md3.7 KB
---
name: setup
description: >-
  Walk the user through rote's first run: import the MCP servers they
  already use, compile one of their skills, and show that the compiled skill
  gives the same answer, faster and cheaper. Use when the user says "set up
  rote", "get started with rote", "try rote on my skills", "onboard me", or
  just installed rote and asks what to do first.
---

# Set up rote

You relay `rote setup`. rote asks the questions and makes the plans, and the
user answers them. You never answer a question or approve a plan yourself,
and you never pass `--yes`.

## 1. Run it

```sh
uvx --from rote-cli rote setup --agent-mode yes --json
```

It prints one JSON object on stdout. Exit 0 or 1 with `status: "done"`
means it finished: go to step 3.

## 2. Each stop: ask, then run `next`

Exit 2 is a stop with `status: "action_required"`. Tell the user what
`ask` says, in your own plain words, with the step it belongs to
(`step.index` of `step.total`). Keep money and time in it when the plan
spends any. Then wait for their answer.

| `reason` | What the user decides | What you run |
| --- | --- | --- |
| `missing_answer` | the question in `ask`, from `choices` (`skills` and `servers` describe them) | `next[0].command`, with the placeholder replaced by their answer as `answer_with` says |
| `confirmation_required` | yes or no to the plan | yes: `next[0].command`, no: `next[1].command` |
| `authorization_pending` | approve each `logins[].authorization_url` in their browser | once they say done: each `rote mcp login --complete` command in `next`, then the last `next` command |
| `person_required` | run `next[0].command` in their own terminal (you cannot) | once they say done: the last `next` command |

Run exactly the command `next` gives. rote remembers earlier answers, so it carries only the new one.
Never add a flag it does not name. An error (exit 1, `error`) names its fix:
tell the user, and run `rote setup` again once it is fixed.

When rote asks which servers to log in to (step `login`) and says the
skill does not say which servers it calls, read the skill and pick the
servers whose tools it calls.

When rote asks which skill to compile (`reason: missing_answer`, step
`skill`), read the SKILL.md of each choice before you answer, and
recommend one to the user by the rule below, with one line on why. Say
which choices it rules out.

<!-- rote:worth -->
### Is it worth compiling?

Compiling to the skill runtime pays off when most of the skill's work is
fixed steps: tool calls, lookups, filtering, arithmetic, formatting. The
compiled skill does those in code and stops for you only where the skill
needs judgment. Each stop is a round trip that re-reads the conversation,
so a skill that is mostly judgment (search, read, then write an answer)
runs slower and costs more compiled. Measured: Atlassian's
search-company-knowledge took 4x longer at 3x the cost, while
expense-audit ran 3.6x faster at 62% less.

Read the SKILL.md before compiling, and count the steps that need
judgment: choosing, ranking, summarizing, writing prose. If a run needs
more than two, tell the user compiling will not pay off and why, and do
not compile unless they still want to. rote checks the same thing after
its first step and stops (`--compile-anyway` overrides it), so a
misjudgment costs cents, not a whole compile. This applies to
`--runtime skill`: on a workflow runtime a judge is an API call, not a
round trip.
<!-- /rote:worth -->

## 3. The verdict

The last object has `answer` (did the compiled skill give the same answer),
`sides` (time, tokens and cost of each), and `next` (how to use the compiled
skill from an agent). Lead with `answer`, then the time and cost of each
side, then the next step.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall