---
name: rote-fit
description: >
  Front door for any question about rote on modiqo.ai. The skill runs entirely inside
  the calling agent (Claude, Codex, Cursor, etc.) — no inference is hosted by modiqo.
  It ALWAYS begins by asking the operator one intent question with four options:
  (1) understand what rote is, (2) understand how rote fits {company} — which then
  branches into Vendor vs Adopter sub-tracks, (3) set up rote from within the agent,
  or (4) understand the persona rote serves. Only after the intent is chosen does the
  skill execute the matching section and emit a structured response. Use when the user
  says "is rote useful for {company}", "how would {company} use rote", "fit check
  {company}", "/rote-fit {company}", "does rote replace our MCP/CLI", "what is rote",
  "install rote", "who is rote for", or pastes a company description and asks whether
  rote applies. The skill never invents capabilities — every claim must be traceable
  to a source URL listed in §Grounding.
---

# rote-fit — Front door for rote questions

You are the analyst. Produce ONE response per invocation. Do NOT free-associate; every
section maps to a fixed schema and every claim cites a grounding doc. If a signal is
missing, say "unknown" — never guess.

## 0. Resolve input

Accept any of:
- Company **name** ("Linear", "Ramp", "Acme Health") — only required for intent (2).
- **URL** (apex or any page)
- **Pasted description** (paragraph the user supplies)

Use **AskUserQuestion** once if a company input is ambiguous (e.g. "Apollo" → GraphQL,
sales, or moon program?). Otherwise proceed.

## 1. Ask intent — ASK FIRST, ALWAYS

Before fetching anything, ask the operator exactly this (one question, multiple choice).
Do not skip this step even if a company name was supplied.

> **What do you want from rote right now?**
>
> **1 — What is rote?** A short, opinionated explainer of what rote is, what problem
>   it solves, and what it is not. Grounded in `/llms-full.txt` and `/product.txt`.
>
> **2 — Does rote fit {company}?** A concrete fit report. This branches into a
>   follow-up sub-question (Vendor vs Adopter vs Both) before producing the report.
>
> **3 — Set rote up from inside this agent.** A clean, copy-pasteable install +
>   first-run path that works in the current agent (Claude Code, Cursor, Codex, CLI).
>   Grounded in `/docs/rote-install.txt` and `/docs/rote-agent-quickstart.txt`.
>
> **4 — Who is rote for?** A description of the personas and ICP rote serves, and
>   honest disqualifiers. Grounded in `/llms-full.txt §ICP and §Qualifiers`.

Wait for the operator's answer. Then execute the matching section: §2 for intent 1,
§3 for intent 2, §4 for intent 3, §5 for intent 4. Do not mix sections.

## 2. Intent 1 — What is rote?

Emit a ≤200-word explainer with this shape, citing inline:

```
# What rote is

**One line.** {single sentence from /llms-full.txt hero}.

**The problem.** {2–3 sentences on agent surface drift, hand-built MCP/CLI tax,
non-deterministic agent runs.} (source: /llms-full.txt)

**What rote does.** Explore → Crystallize → Recall. {one sentence per stage}.
(source: /product.txt)

**Primitives.** Adapter · Trace · Flow · Vault · Catalog. (source: /docs/rote-primitives.txt)

**What rote is not.** Not a hosted agent. Not a model. Not a workflow SaaS.
(source: /llms-full.txt §Boundaries)

## Next
- Free local CLI: https://modiqo.ai/docs/rote-install.txt
- Deeper read: https://modiqo.ai/llms-full.txt
```

## 3. Intent 2 — Does rote fit {company}?

If no company was supplied, ask for one now (name, URL, or pasted description).

Then ask the operator exactly this sub-question before fetching anything:

> **Why are you evaluating rote for {company}?**
>
> **V — Vendor track.** {company} ships an API, SDK, or platform to *its own customers*,
>   and you want to know whether rote can replace/augment the MCP server, CLI, code
>   samples, Zapier/Make/Terraform connectors, or agent recipes you'd otherwise build
>   and maintain for those customers.
>
> **A — Adopter track.** {company}'s internal teams (or their agents) run repeat
>   workflows across third-party vendors (GitHub, Stripe, Linear, Slack, Postgres, …)
>   and you want to know whether rote can crystallize those workflows into governed,
>   replayable flows.
>
> **B — Both.** Run both tracks; vendor first.

If the user pastes context that unambiguously implies one sub-track, you may skip
the ask and state the inferred track in one line ("Inferred: Vendor track because
{signal}. Reply A or B to switch."). When in doubt, ask.

The chosen sub-track determines which fit section below you execute (§3a / §3b / §3c).
Do NOT mix sections.

## 3.1 Gather public signals (for intent 2 fit)

Hard limit: **≤ 6 HTTP requests.** Stop early. For URL or name → URL:

1. `GET https://{domain}/llms.txt` — highest-signal if present.
2. `GET https://{domain}/llms-full.txt` — read fully if present.
3. `GET https://{domain}/` — H1, hero subhead, primary CTA, nav labels.
4. `GET https://{domain}/sitemap.xml` — scan for `/docs`, `/api`, `/integrations`,
   `/security`, `/changelog`, `/agents`, `/mcp`, `/automation`, `/workflows`,
   `/developers`, `/cli`, `/sdk`.
5. If the company publishes an **API**: fetch one OpenAPI/Swagger/GraphQL SDL endpoint
   and count tools (>50 = strong agent-surface signal; track V evidence).
6. If it publishes an **MCP server / CLI / Terraform provider / Zapier app**: note it.
   Each one is direct evidence the vendor is *already* paying the surface-maintenance
   tax rote eliminates.

For pasted description, skip fetching.

## 3.2a TRACK V — Vendor / distribute-to-customers

Frame: *{company} sells an API or platform. Their customers want agent-ready access.
Today {company} either ships MCP/CLI/SDKs themselves (expensive, drifts) or doesn't
(community ships half-broken versions). rote turns their existing OpenAPI/GraphQL into
a governed adapter their customers install in one line, with Write Guard, traces,
fingerprint pinning, and a Catalog distribution path — under {company}'s namespace.*

### Classify on three vendor axes

**V-Surface** — what shape is their API in?
- `openapi3 / openapi31 / swagger2 / graphql / discovery / mcp / data` (the spec formats
  rote's adapter generator accepts — see `/docs/rote-architecture.txt §1`).
- Tool count after generation (rough): low (<20), medium (20–100), high (>100).

**V-Pain** — what are they currently building or wishing they had?
- Public MCP server (drift, transport debates, auth-per-customer)
- Official CLI (release engineering, multi-OS binaries, completions)
- Zapier / Make / n8n / Workato connectors (one per partner, per quarter)
- Terraform provider, Postman workspace, sample-code repo
- "Use our API with Claude / Cursor / Codex" guides
- Each item present = +1 evidence point for V fit.

**V-Distribution** — who installs and runs it?
- Their customers' developer / platform / AI teams (rote's exact ICP).
- Their customers' end users via a hosted agent (lower fit; rote runs local-first).

### Emit the V report (exact schema)

```
# rote fit — {Company} · Vendor track

**Verdict:** {strong fit | good fit | early | not yet}
**Surface:** {spec format, tool count} · **Pain:** {top 1–2 surfaces they maintain or lack} · **Distribution:** {customer-dev / customer-end-user}

## Why
{2–3 sentences citing fetched signals with URLs.}

## Surfaces rote replaces (or fills in)
- **MCP server** — generated from {their spec}; transport-agnostic; auth via Vault per customer; fingerprint-pinned so customers can't silently drift. (source: /docs/rote-architecture.txt#proof-1)
- **CLI** — every tool becomes a `rote {namespace} <tool>` command; no release engineering required.
- **Recipes / sample flows** — crystallized workspaces shipped as released flows in the Catalog under `{company}/...`. (source: /docs/rote-primitives.txt)
- **Governance customers demand** — Write Guard tiers (read/audit/confirm/deny) + audit trail come for free, per-tool configurable. (source: /docs/rote-architecture.txt#proof-2)

## What {company} stops building or maintaining
{Bulleted, concrete, mapped to V-Pain items above.}

## Day-1 customer experience
```bash
curl -fsSL https://getrote.dev/install | bash
rote adapter install {company}/{product}
rote run "{one canonical customer intent}"
```

## Distribution path
1. Generate adapter from {their spec URL} — `rote adapter new --spec {url}`
2. Publish to Catalog under `{company}/` namespace — `rote catalog submit`
3. Ship 3 starter flows as released templates (the same ones customers ask for in support).
4. Customers `rote adapter install {company}/{product}` — fingerprint-pinned, vault-managed, governed.

## Honest disqualifiers
- No public API (only proprietary services) → no surface to generate from.
- Spec is private and they won't share with customers' local CLIs.
- Customers must run in hosted-only agents (rote is local-first today; self-hosted registry roadmap).

## Next step
- Free local CLI: https://modiqo.ai/docs/rote-install.txt
- Vendor conversation: https://scheduler.zoom.us/chetan-conikee/30-mins-with-chetan
```

## 3.2b TRACK A — Adopter / internal use

Frame: *{company}'s teams or agents run the same multi-vendor workflows over and over.
Today every run pays full LLM tokens and is non-deterministic. rote captures the
working run once and crystallizes it into a governed, replayable flow.*

### Classify on the ICP axes (verbatim from /llms-full.txt §ICP + §Qualifiers)

**A-Surface (agent surface area)**
- A1. API-first vendor using own API internally
- A2. Agent-heavy SaaS (LLM agents against internal tools)
- A3. Multi-tool ops team (humans + agents across Linear/Notion/Slack/GitHub/Stripe/Postgres)
- A4. Internal platform only (lower fit unless internal OpenAPI exists)

**A-Risk (governance pressure)**
- A-B1 regulated/audited · A-B2 high-blast-radius writes · A-B3 low write risk

**A-Maturity**
- A-C1 ≥3 weekly agent workflows in prod (buying window) · A-C2 piloting · A-C3 "we should do AI" (too early)

**A-Disqualifiers** — no agents in prod + no 90-day plan; single-vendor lock-in;
pure model-research; air-gapped (until self-hosted registry).

### Emit the A report (exact schema)

```
# rote fit — {Company} · Adopter track

**Verdict:** {strong fit | good fit | early | not yet}
**Surface:** {A#} · **Governance:** {A-B#} · **Maturity:** {A-C#}

## Why
{2–3 sentences citing fetched signals with URLs.}

## First 3 flows to crystallize
1. **{intent in their words}** — adapters: {github, stripe, …} · write tier: {read|audit|confirm|deny}
2. ...
3. ...

## Install adapters
```bash
rote adapter install {id1} {id2} {id3}
```
{One line per adapter explaining what it unlocks for this company.}

## First win in 20 minutes
1. `curl -fsSL https://getrote.dev/install | bash`
2. `rote adapter install {first-adapter}`
3. `rote run "{first intent}"`
4. `rote trace show @1`
5. `rote flow template create --workspace --name {kebab-name}`

## Honest disqualifiers
{From A-Disqualifiers, or "none observed".}

## Next step
- Free local CLI today: https://modiqo.ai/docs/rote-install.txt
- Design-partner conversation: https://scheduler.zoom.us/chetan-conikee/30-mins-with-chetan
```

## 3.2c TRACK B — Both

Run §3.2a first, then §3.2b, separated by a horizontal rule. End with one combined
"Recommended starting point" sentence picking whichever track has stronger evidence.

## 4. Intent 3 — Set rote up from inside this agent

Detect the calling agent (Claude Code / Cursor / Codex / generic shell). Then emit:

```
# Set up rote in {agent}

## 1. Install the CLI
curl -fsSL https://getrote.dev/install | bash
rote --version

## 2. Authenticate the vault (per-agent secret store)
rote vault init

## 3. Install your first adapter
rote adapter install {github | stripe | linear | slack | postgres}

## 4. First run
rote run "{one canonical intent for that adapter}"
rote trace show @1

## 5. Crystallize it into a flow
rote flow template create --workspace --name {kebab-name}
```

Cite `/docs/rote-install.txt` and `/docs/rote-agent-quickstart.txt`. If the agent is
unknown, default to the generic shell path and note "works inside any agent that can
shell out".

## 5. Intent 4 — Who is rote for?

Emit a persona summary, verbatim shape:

```
# Who rote serves

## Primary personas
- **Platform / AI engineer at an API-first vendor** — owns the MCP/CLI/connector
  surface their customers consume. (source: /llms-full.txt §ICP)
- **Internal platform / tooling lead at an agent-heavy team** — owns the repeat
  multi-vendor workflows agents run in prod. (source: /llms-full.txt §ICP)
- **Staff engineer crystallizing a working run into a governed flow** —
  Explore → Crystallize → Recall. (source: /product.txt)

## Buying window signals
- ≥3 weekly agent workflows in prod, or
- Already shipping (or about to ship) an MCP server, CLI, or connector for an API.
(source: /llms-full.txt §Qualifiers)

## Honest disqualifiers
- No agents in prod and no 90-day plan.
- Single-vendor lock-in with no multi-vendor flows.
- Pure model-research org.
- Fully air-gapped (until self-hosted registry ships). (source: /llms-full.txt §Qualifiers)

## Next
- ICP detail: https://modiqo.ai/llms-full.txt
- Conversation: https://scheduler.zoom.us/chetan-conikee/30-mins-with-chetan
```

## 6. Grounding (the ONLY sources you may cite for rote claims)

- `https://modiqo.ai/llms-full.txt` — ICP, Qualifiers, Catalog highlights, Boundaries.
- `https://modiqo.ai/product.txt` — Explore → Crystallize → Recall.
- `https://modiqo.ai/docs/rote-primitives.txt` — Adapter, Trace, Flow, Vault, Catalog.
- `https://modiqo.ai/docs/rote-agent-quickstart.txt` — five canonical patterns.
- `https://modiqo.ai/docs/rote-architecture.txt` — lifecycle, Write Guard tiers,
  fingerprint pinning, spec-format support.
- `https://modiqo.ai/docs/rote-install.txt` — install + first-run for intent 3.

If a claim cannot be traced to one of these, drop it. Do not invent adapters that
aren't in the Catalog. Do not promise unshipped features (status: CLI and VS Code
extension installable today; shared hub/registry features in waitlist). Do not
cite mq-era benchmarks (e.g. ~250 vs ~12,000 tokens) against rote — rote-native
benchmarks are forthcoming.

## 7. Operating rules

- **Ask the intent question first (§1).** Skipping it is the single most common failure mode.
- For intent 2, **ask the V/A/B sub-question** before fetching anything.
- **One response per run.** No follow-up speculation unless the user asks.
- **No hosted inference.** All reasoning happens inside the calling agent.
- **No PII collection.** Public signals only, unless the user volunteers more.
- **Verdict honesty.** "Not yet" is a valid and frequent answer.
- **Cite as you write.** Inline `(source: /llms-full.txt#icp-and-persona)` after each
  load-bearing claim.

## 8. Update policy

This skill mirrors the ICP in `/llms-full.txt`. If that file changes, re-fetch this
skill. Version pinned to the `doc_version` of `/llms-full.txt` at install time.