Quickstart

Three steps. Ninety seconds.
Inside Claude Code.

CUIT is built for agentic coding tools. The product surface is the MCP server and a pair of Claude Code skills — /cuit-instrument wires CUIT into a fresh repo; /cuit-loop closes the regression-spec loop from a recorded session.

You will not be writing curl commands. You'll be talking to Claude Code about your bug, and watching it pull session data, generate a spec, and run it — using the same tools your engineers already use every day.

90 secondsClaude Code-nativeMCP-firstNo curl

What you need

Claude Code installed. Either the CLI (claude.ai/code) or the VS Code/JetBrains extension. If you don't have it, install it first — this page is written for you to read once you're inside the editor.
A tenant token. Get one in 10 seconds at /signup — no human in the loop. The form returns your bearer token; copy it now.
A repo to work in. Doesn't matter what framework — Next.js, Vite, Remix, Astro, whatever. The /cuit-instrument skill detects it and writes the integration for you.

The 3 steps

Steps 1 and 2 happen once per machine. Step 3 you'll repeat for every app you instrument.

Drop the CUIT MCP server into Claude Code

Edit (or create) ~/.claude/mcp_servers.json and add the cuit entry below. Paste your tenant token in the env block.

json{
  "mcpServers": {
    "cuit": {
      "command": "npx",
      "args": ["-y", "@cuit-saas/mcp"],
      "env": {
        "CUIT_API_URL": "https://cuit-saas-pilot.fly.dev",
        "CUIT_TENANT_TOKEN": "<paste-your-token-here>"
      }
    }
  }
}

Restart Claude Code. The CUIT MCP server boots in the background and exposes 12 tools that Claude can call mid-conversation:

cuit__query_sessions

cuit__find_similar_sessions

cuit__flake_rate

cuit__bug_class_distribution

cuit__detect_app_shape

cuit__propose_instrumentation

cuit__generate_spec_from_session

cuit__run_spec

cuit__regression_test_for_pr

cuit__audit_export

cuit__verify_session_round_trip

cuit__list_instrumentations

Verify it loaded: in Claude Code type /mcp list — you should see cuit with 12 tools.

Open your app's repo in Claude Code and run /cuit-instrument

Inside Claude Code, with your app's repo as the working directory, just type:

claude code/cuit-instrument

The skill walks 5 phases. You watch:

Detect — calls cuit__detect_app_shape against your repo. Reports framework, state lib, candidate root + state files.
Propose — calls cuit__propose_instrumentation. Returns a structured diff: which files to create, which to edit, what to add to package.json.
Apply — Claude uses its Edit/Write tools to write the diff. You see every change before it commits. You can reject or refine inline.
Verify — Claude runs pnpm install + pnpm typecheck, then calls cuit__verify_session_round_trip to confirm a session actually reaches the warehouse.
Confirm — Summary of files changed, first generated spec, dashboard URL.

Wall-clock: 10–15 minutes the first time. On a typical Next.js + Zustand app it's closer to 8.

Hit a bug. Type /cuit-loop. Done.

From here on, this is the daily workflow. When you find a bug:

Open your app in Chrome with ?cuitRecorder=1. Reproduce the bug. Stop the recording.
Back in Claude Code, attach the session JSON (or just paste it) and type:

claude code/cuit-loop

The skill auto-detects which flow you're in:

Flow A — bug reproduction. Spec fails on first run (RED). Claude walks the diagnose-fix-rerun loop until GREEN.
Flow B — baseline lock-in. Spec passes on first run (GREEN). Claude commits it as a permanent regression gate.

You did not write a test. You did not write a curl command. You described the bug to Claude, and it generated, ran, and gated the regression for you.

What this unlocks in Claude Code

Once the MCP server is connected, ANY conversation can query the warehouse mid-task. Try saying these in your next Claude Code session:

"Find sessions similar to the bug I just fixed in PR #487."

"Show me the bug-class distribution for the last 28 days."

"What's our flake rate trend over the last quarter?"

"For the segment-drag bug, generate a regression spec from the most recent matching session and run it."

"Detect the app shape of ./apps/dashboard and propose how to instrument it."

Claude routes each one to the matching MCP tool, makes the API call, and reasons about the response. Your engineering team gets CUIT's entire warehouse as ambient context — without leaving the editor.

Get your token. Connect the MCP. Type a slash command.

That's the whole onboarding. The first time anyone on the QA team should hit a curl prompt is when they're building CI integrations — not when they're evaluating the product.

▸ Need REST instead?For CI integrations, hostile network environments, or non-agentic toolchains.

The MCP server is a thin wrapper over the REST API. If your environment blocks Claude Code or you need to script against CI, you can drive everything via curl against https://cuit-saas-pilot.fly.dev.

Full endpoint reference + per-endpoint curl examples lives at /docs/api. The OpenAPI 3.0 spec lives at https://cuit-saas-pilot.fly.dev/openapi.json — codegen-ready for any language.

Minimum proof-of-life:

bash# Set token from /signup, then:
curl -s -H "Authorization: Bearer $CUIT_TENANT_TOKEN" \
  https://cuit-saas-pilot.fly.dev/v1/me | jq

# Round-trips through bearer auth + RLS + Postgres,
# returns your tenant info.

But honestly — if you're here for the first time, go back to step 1 above and use Claude Code. This walkthrough was written assuming you're an agentic-AI-native developer.

Three steps. Ninety seconds.Inside Claude Code.