Camino in Claude Code.

1. What the MCP server is

MCP — the Model Context Protocol — is the standard way to give Claude Code extra tools. An MCP server is a small program that Claude Code starts in the background and talks to. Camino’s gives Claude nine tools, each one a call to Camino’s API made with a token you create, so it can only see and do what you can.

You do not call the tools yourself. You ask in plain words — “what’s next on ronda?” — and Claude picks the tool. Each tool’s description tells Claude the rule that matters most: run the step’s Do, submit the exact output, and remember there is no tool to mark a step done.

2. Can it tell me my next step?

Yes. camino_next returns the one thing to do now and the current step on every track. The one thing is the step the project’s overview puts in front of you, chosen the same way: a step whose check failed or that has a blocker first, then one you can work on, then the one you last worked on, and never one somebody else has. So Claude and the overview name the same step. Asked “what’s next on ronda?”, this is what Claude gets back:

ronda — Ronda
Do this: install:A02 — Prerequisites

One current step per track:
  install    A02      active                 1/14  Prerequisites
  pilot      P02      awaiting_verification  1/9  Booking form and confirmation
  lane-a     LA03.1   active                 12/30  Plan s4-stripe-payments
             stage 1 of 5 of LA03 · s4-stripe-payments
  d1-reddit  D1-02    active                 1/3  Answer a real question, with the tracked link where the rules allow
             channel r/pilates: 1 of 3 sign-ups (9 days left)
             link: https://goronda.com/?utm_source=reddit&utm_medium=community&utm_campaign=camino

Use camino_step with a code to get the step's instructions in full, and camino_claim before you start so the other people in this project can see what you have picked up.

The next step is the Do this line. A step that belongs to a sprint says which: LA03.1 is stage 1 of 5 of LA03, run for s4-stripe-payments. To read a step in full, Claude calls camino_step with its code — section 5 shows what that returns.

D1-02 is different: it is an activity in a distribution channel, r/pilates. Under it are the channel’s number against its bar and the tracked link to post, so when the step says to use “this channel’s tracked link”, Claude already has it and does not need to send you to the Distribute page. The channel is judged on its number, not on whether the activity was done (How Camino works, section 10).

3. Set it up

1. Make a token. In Camino, open API tokens in your avatar’s menu, name the token for where it will live (“claude-code-macbook”) and create it. Copy it straight away: only a hash is stored, so it is shown once. If you lose it, revoke it and make another.
2. Build the server, once. It is not published as a package yet, so it runs from a copy of the Camino repository. In that repository:
   Terminal Copy

   pnpm install
   pnpm --filter camino-mcp build

   When it is published, this page will name the package and this step goes away.
3. Register it in the project you are building — run this in that project’s folder, not in Camino’s. Put your token in, and the absolute path to your copy of Camino:
   Terminal Copy

   claude mcp add camino \
     -e CAMINO_TOKEN=camino_api_your_token_here \
     -e CAMINO_URL=https://waypoint-red-nine.vercel.app \
     -- node /absolute/path/to/camino/packages/mcp/dist/index.js

   The path has to be absolute and has to end in dist/index.js, the built file. Node cannot run the TypeScript source.
4. Check it. Start Claude Code in that folder and type /mcp; camino should be listed as connected. Then ask “what’s next on ronda?” — using your project’s slug, the part of its address after /p/.

4. What it can do: nine tools

5. A sprint stage, start to finish

Ronda’s sprints run a five-stage loop, and every stage carries its exact commands with the sprint’s name filled in. Here is the first stage of the Stripe sprint, run from Claude Code in Ronda’s repository.

1. You: “What’s next on ronda?” Claude calls camino_next (section 2) and tells you LA03.1, Plan s4-stripe-payments, is active on lane A.
2. You: “Claim it and show me the step.” Claude calls camino_claim, then camino_step, and gets this:
   camino_step Copy

   LA03.1 · Plan s4-stripe-payments
   track: Lane A — the API chain    status: active    evidence tier: paste
   stage 1 of 5 of LA03 · s4-stripe-payments
   picked up by: Alex — say so before taking it over
   
   WHY
   Planning is the one gate that needs your judgement, so it is worth doing properly (I.10). If several sprints are ready to plan, do them in one sitting and the builds run back to back — but each is approved on its own.
   
   DO
   ⌨ On `main`, fresh session:
   
   ```text
   claude
   /effort high
   /sprint-plan s4-stripe-payments
   ```
   
   🤖 Drafts `plan.md` and `deps-allowed.txt` from the `s4-stripe-payments` entry in `docs/roadmap.md`, runs `@plan-reviewer`, fixes, re-runs once, stops with the verdict. Scope and tier come from the roadmap entry, not from the model's reading of the slug.
   
   RESULT
   `docs/sprints/s4-stripe-payments/` with `plan.md`, `plan-review.md`, `deps-allowed.txt`.
   
   CHECK (tier: paste)
   The reply ends "Plan gate: waiting for Alex's approval." Paste it, and `ls docs/sprints/s4-stripe-payments/`.
   
   Do the work, then submit exactly what the commands printed. The rubric above is what an independent verifier will judge it against — it does not see this conversation.

3. You run the command in the Do. /sprint-plan is one of the skills Ronda’s step A09 installed, and it is marked for you to run rather than the model — planning is the gate that needs your judgement. So you type /sprint-plan s4-stripe-payments in a fresh session on main, as the Do says, and it drafts the sprint plan from the sprint’s entry in docs/roadmap.md and stops at the plan gate.
4. You: “Submit that reply and ls docs/sprints/s4-stripe-payments/ to Camino as the evidence for LA03.1.” Claude runs the listing, calls camino_submit_evidence with the reply and the listing, and the verifier answers:
   verdict Copy

   LA03.1: PASS — the step is now done.
   
   The reply ends with "Plan gate: waiting for Alex's approval." and the listing shows plan.md, plan-review.md and deps-allowed.txt in docs/sprints/s4-stripe-payments/, which is the Result the step describes.
   
   Use camino_next for what comes next.

5. The next stage, LA03.2 Approve, asks for an attestation — you reading the plan and signing it off — so it is done in the browser, by you. LA03.3 Arm and run starts /sprint-run, which builds and reviews the whole sprint unattended; when it finishes, its evidence goes in the same way.

That is the pattern for every step: next, claim, step, do the Do, submit the real output, read the verdict. A failed verdict opens a blocker and leaves the step open; fix what the reasons describe and submit again.

6. Put the rules in CLAUDE.md

Claude Code reads CLAUDE.md at the start of every session. A few lines there mean it uses Camino the same way every time, without being asked. For Ronda:

## Camino

This repository's build plan lives in Camino, project `ronda`.

- At the start of a session, call `camino_next`, and again after every verdict.
- Before working on a step, call `camino_claim`, then `camino_step` for its instructions. Run the Do as written; do not paraphrase it.
- Submit what the commands printed with `camino_submit_evidence`: tier `auto` with the exit code when a command produced it, `paste` otherwise. Never summarise the output.
- If a step cannot be attempted, call `camino_open_blocker` and say exactly what is missing. Do not submit evidence you expect to fail.
- Never say a step is done. The verifier decides; report its verdict word for word.
- Steps whose Check asks for an attestation, and slash commands such as `/sprint-plan`, are mine to run. Tell me when one is next and stop.

7. What it will not do

• Mark a step done, or pass one. There is no tool for it, because there is no way to do it anywhere in Camino. Claude reports; the verifier decides.
• Attest. A typed confirmation is a person saying they did something, so it is made in the browser.
• Change the plan. Correcting, skipping or reopening a step is done on the step’s page, with a reason. Claude can open a blocker saying a step is wrong.
• Run your slash commands. Skills like /sprint-plan that are marked for you to invoke stay yours; Claude will tell you when one is next.
• Reach other projects. The token acts as you, in projects you are a member of — and a project you are not in answers exactly like one that does not exist.
• Settle a step from catch-up for you. Catch-up reports; the steps you agree are done are settled by you, ticked and attested on the project’s catch-up page in the browser, and they show as attested, never as verified.
• Upload your repository. camino_catch_up reads it with git on your machine, committed files only, and sends short facts about the files each step mentions: whether each is there, its length, its first lines. Anything shaped like a key is cut out first, and files that hold secrets, such as .env, are named but never opened. camino catch-up --dry-run (section 9) prints exactly what a pass would send, and sends nothing.
• Go faster than 60 requests a minute per token, so a loop that goes wrong stops itself.

8. When something goes wrong

9. The same thing from a terminal

camino is Camino’s command line: the same client and the same output, for working without an agent in the loop. It is built from the same repository with pnpm --filter camino-cli build, and reads the same token.

camino next
camino step LA03.1
camino claim LA03.1
camino submit A01 --auto -- pnpm test
camino blocked A04 "Docker is not running"
camino catch-up ronda

camino submit --auto runs the command itself and submits its output with the exit code — the most trustworthy evidence there is, because nobody typed it. There is no camino done. camino catch-up, run in your project’s folder, prints the same report as camino_catch_up and shows its progress as it goes, and camino seed shares the same facts with Shape before an interview, as camino_seed does.