# Connect a coding agent

> Install the Super Assist plugin in Claude Code or the skill in another agent, add the MCP server by URL, run setup and sync, and disconnect an agent under Account.

The Super Assist plugin gives a coding agent what it needs to work on your app: a skill that teaches it `@super-assist/react` and runs commands such as `setup` and `sync`, and a connection to Super Assist's MCP server, through which it creates your agent, project, pages and journeys as you, with no key to copy. Claude Code installs the whole plugin; other agents install the skill and add the MCP server by its URL.

## Install the plugin in Claude Code

In Claude Code, from your app's repository:

1. Add the marketplace and install the plugin:

   ```txt
   /plugin marketplace add mertdogar/super-assist-templates
   /plugin install super-assist@super-assist
   ```

   The install asks for a scope: user for all your repositories, project to share it with everyone who works in this one through `.claude/settings.json`, or local for you in this one. When the install summary says to, run `/reload-plugins`.

2. Run `/mcp`, select `plugin:super-assist:api`, and [sign in](#sign-in-to-super-assist) in the browser.

From a shell, the same steps are `claude plugin marketplace add mertdogar/super-assist-templates` and `claude plugin install super-assist@super-assist`.

The plugin brings three things:

- The `super-assist` skill and its [commands](#run-the-skills-commands).
- The MCP server `plugin:super-assist:api`, at `https://superassist.app/mcp`.
- Two hooks. At the start of a session they note the app's assisted pages, and when Claude finishes a turn that changed them, they ask it to [sync](#keep-the-page-catalog-in-sync).

Claude Code doesn't update plugins from this marketplace on its own. Turn updates on under `/plugin` › **Marketplaces** › **Enable auto-update**, or update by hand with `/plugin marketplace update super-assist`.

## Install the skill in another agent

Codex, Cursor, GitHub Copilot and the other agents the `skills` CLI supports install the skill from your app's repository:

```bash
npx skills add mertdogar/super-assist-templates
```

The skill comes with its commands and the script that scans your app's routes, which needs Node and nothing else. Installed this way it has no hooks, so ask for `sync` after you change pages, and no MCP server until you [add it](#add-the-mcp-server-by-url). In Claude Code, install the plugin instead: with both, Claude Code has the skill twice.

## Add the MCP server by URL

The MCP server is at `https://superassist.app/mcp`. A client signs in to it in the browser, so no key goes in its configuration.

### Codex

Add the server and sign in:

```sh
codex mcp add super-assist --url https://superassist.app/mcp
codex mcp login super-assist
```

The server can also go in `~/.codex/config.toml` by hand, followed by the same `codex mcp login`:

```toml title="~/.codex/config.toml"
[mcp_servers.super-assist]
url = "https://superassist.app/mcp"
```

The Codex IDE extension and the ChatGPT desktop app share this configuration.

### Cursor

Add the server to `~/.cursor/mcp.json` for every project, or to `.cursor/mcp.json` in the app's repository:

```json title="~/.cursor/mcp.json"
{
  "mcpServers": {
    "super-assist": {
      "url": "https://superassist.app/mcp"
    }
  }
}
```

Cursor signs in with OAuth to servers that require it, as this one does. Turn the server on or off from **Customize** in the sidebar.

### VS Code

Run **MCP: Add Server** from the Command Palette, choose **HTTP (HTTP or Server-Sent Events)**, enter `https://superassist.app/mcp` and a server ID such as `super-assist`, and pick where to save it. The same server in a workspace's `.vscode/mcp.json`:

```json title=".vscode/mcp.json"
{
  "servers": {
    "super-assist": {
      "type": "http",
      "url": "https://superassist.app/mcp"
    }
  }
}
```

A browser window opens to sign in the first time VS Code connects to the server.

### Other clients

Claude and ChatGPT connect at the same URL. A client Super Assist doesn't accept yet, such as Windsurf or Gemini CLI, calls the API with an organization key and curl instead, as [Set up through the API](https://superassist.app/how-to/set-up-through-the-api.md) shows.

## Sign in to Super Assist

Signing in from a coding agent opens superassist.app in the browser. Sign up there first if you're new: signing up in the middle of connecting doesn't return you to the agent.

1. Sign in to Super Assist.
2. When you belong to several organizations, pick the one the agent works in.
3. Press **Allow** under "_Claude Code_ wants to act as you in _your organization_". You allow each client once per organization.

The connection acts as you in that organization. It can do what you can do in the dashboard, with your role read on every call, until you [disconnect it](#disconnect-a-coding-agent) or leave it unused for 30 days. To work in another organization, sign in again: in Claude Code, `/mcp` › `plugin:super-assist:api` › **Clear authentication**, then sign in.

## Run the skill's commands

In Claude Code, type `/super-assist` and a command, such as `/super-assist setup`. In another agent, ask for the command by name, such as "run super-assist sync".

| Command          | What it does                                                                                                             |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `setup`          | Adds the panel to the app, reuses or creates its agent and project, writes the publishable key, syncs, proposes journeys |
| `sync [dir]`     | Makes the page catalog match the code, corrects `destinations`, and asks about journeys that name what's gone            |
| `page [route]`   | Makes a route's page assisted: its name, instructions, content, actions and fields                                       |
| `journey [goal]` | Drafts journeys from the page catalog, as `manual` drafts a member publishes                                             |
| `doctor`         | Checks the library, the key, the connection, the project, catalog drift and journeys naming what's gone                  |

`/super-assist` alone checks the app and recommends the next command, then waits for you to pick one. For any other work with the library, the skill tells the agent which piece to lend for what and which page of these docs to read.

The skill finds the app's project by the publishable key in the app's env file, so it writes nothing else to the repository. When the MCP server isn't connected, it asks you to connect it, or to use an organization key with curl if you'd rather.

The MCP server has two tools. `search` looks up a route in the API's description. `execute` runs the agent's code against the API as you, and Claude Code shows the code before each run. To stop Claude Code asking before `search`, allow it in your settings:

```json title=".claude/settings.json"
{
  "permissions": {
    "allow": ["mcp__plugin_super-assist_api__search"]
  }
}
```

## Keep the page catalog in sync

Sync makes the project's page catalog match the code. It scans the app's routes and the assisted pages they render, fills in what the scan can't read, such as a page name built from a variable, corrects `destinations`, and posts every page with [`replace: true`](https://superassist.app/how-to/set-up-through-the-api.md#post-the-apps-pages). Then it asks about each journey step that points at a page, action or field that's gone: retarget a rename, and drop a deleted step or leave it for you. When it changes a published journey, it asks whether to publish it again.

In Claude Code, the plugin's hooks ask Claude to run `/super-assist sync` once each time a turn changes the assisted pages. In a repository of several apps, they name the app, as in `/super-assist sync apps/web`.

The scan reads the Next.js app router and TanStack Router's file routes. Pages it doesn't read, such as those of React Router or the Next.js pages router, report themselves when end users open them. One sync sends at most 100 pages and 2,000 elements.

## Disconnect a coding agent

In the dashboard, open **Account** from your menu. **Coding agents** lists each of your connections with its client, organization and the day it connected. Press **Disconnect** beside one, and the agent's next call is refused; it signs in again to reconnect.

Owners and admins don't see other members' connections. Removing a member from the organization cuts theirs off.

## Set it up from start.md

Any coding agent, with or without the skill, can set the library up from a recipe. Paste this into the agent in your app's repo:

```txt
Read https://superassist.app/start.md then add an assistant to my app.
```

`start.md` walks it through reading your app, agreeing a plan with you, installing, getting your Super Assist project ready, adding the panel, making a first page assisted, and checking the build.

## Point an agent at the pages

- [`/llms.txt`](https://superassist.app/llms.txt) lists every page with its description, each linked as Markdown.
- [`/llms-full.txt`](https://superassist.app/llms-full.txt) holds every page in one file, for an agent that reads them all at once.
- Every page is Markdown at its URL with `.md` added. This one is [`/how-to/give-agents-the-docs.md`](https://superassist.app/how-to/give-agents-the-docs.md).

Paste a page's `.md` URL into the agent's prompt when you want it to follow that page.