---
title: 'Use Stackbone with coding agents'
description: 'Pick your coding agents once in `stackbone init` or `stackbone link` and the CLI installs the four Stackbone agent skills and wires each one to the documentation MCP server. What each skill does, which agents are supported, and how to set it up by hand.'
position: 7
---

# Use Stackbone with coding agents

> Stackbone ships four Agent Skills that teach your coding agent how to
> build, run and debug agents and workflows on Stackbone. They live in the
> open-source [stackbone-skills](https://github.com/stackbone/stackbone-skills)
> repository and follow the [Agent Skills Open Standard](https://agentskills.io/).
>
> `stackbone init` and `stackbone link` ask which coding agents you use. That
> one answer does two things: it installs the skills for those agents, and it
> adds this site as an MCP server to each one's configuration. From then on the
> agent in your terminal knows the SDK and the CLI without a briefing from you,
> and can look up anything else here.

## Why the skills exist

A coding agent can drive the CLI on its own: `--json` output and meaningful
exit codes. The skills tell the agent **how to work** here: the shapes to
write, the order of operations, the rules that hold everywhere, and which page
of this site to read before it touches a surface. They hold no reference of
their own. Every flag, method and error code comes from the
[MCP server](#give-your-agent-these-docs), so the agent searches this site
instead of guessing, and a skill never goes stale when a flag changes.

## The four skills

You get the same four whatever coding agent you use.

| Skill                                                                                                        | Loads when you are…                                                                                                                                                                                                                                                                       |
| ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [`stackbone`](https://github.com/stackbone/stackbone-skills/blob/main/skills/stackbone/SKILL.md)             | Writing the code inside a workspace with `@stackbone/sdk`: deep agents, durable workflows, the ambient `stackbone` client, calls to sibling agents and connectors, and human-in-the-loop approvals.                                                                                       |
| [`stackbone-cli`](https://github.com/stackbone/stackbone-skills/blob/main/skills/stackbone-cli/SKILL.md)     | Driving the `stackbone` CLI, from `init` and `dev` to operating a running install (runs, approvals, logs, config, prompts, db) and shipping (`build`, `package`, `link`). Covers how to call it (`--json`, `--yes`, exit codes), the loops, and which reference page to read per command. |
| [`stackbone-coder`](https://github.com/stackbone/stackbone-skills/blob/main/skills/stackbone-coder/SKILL.md) | Turning "I want to build X" into a scaffolded agent or workflow. It interviews you one question at a time, wires in the capabilities you say yes to, and hands the code to `stackbone` and the commands to `stackbone-cli`.                                                               |
| [`stackbone-debug`](https://github.com/stackbone/stackbone-skills/blob/main/skills/stackbone-debug/SKILL.md) | Triaging a failure: SDK error codes, HTTP errors from the control plane, stuck runs, parked approvals, connector and build failures. It helps you find the cause and leaves the fix to you.                                                                                               |

> [!NOTE]
> If the SDK or the CLI is new to you, read the [SDK](/docs/sdk/reference/overview) and
> [CLI](/docs/cli/guides/getting-started) docs first.

## Set up your coding agents

### The prompt in `init` and `link`

Run [`stackbone init`](/docs/cli/reference/init) or
[`stackbone link`](/docs/cli/reference/link) in a terminal and you get a
checklist of the supported agents, with the ones we can see on your machine
pre-ticked. `link` also looks at the directory it is linking; `init` cannot —
the workspace it checks is the one it just created — so there it is your home
folder alone. Tick as many as you like, or none.

Whatever you tick gets both halves at once: the four skills plus a small
`find-skills` helper, and a `stackbone-docs` entry in that agent's own MCP
configuration. The CLI patches `.gitignore` so the per-agent skill copies stay
out of your commits; the MCP config files are left committable on purpose, so a
teammate who clones the repository inherits the documentation server without
running anything.

| Agent          | MCP config it gets                                         |
| -------------- | ---------------------------------------------------------- |
| Claude Code    | `.mcp.json` in the workspace                               |
| Cursor         | `.cursor/mcp.json` in the workspace                        |
| GitHub Copilot | `.vscode/mcp.json` in the workspace                        |
| Gemini CLI     | `.gemini/settings.json` in the workspace                   |
| Windsurf       | `~/.codeium/windsurf/mcp_config.json`                      |
| Cline          | the Cline extension's settings in VS Code's global storage |
| Codex CLI      | `~/.codex/config.toml`                                     |

Every write merges: your other MCP servers stay, and an existing
`stackbone-docs` entry is left exactly as you edited it. Re-running the command
is safe and reports each target as `already`.

If a step fails (offline, registry down, a config file we cannot parse) the CLI
warns and leaves the workspace usable. The other agents are still set up.

When the skills land, `init` ends with a prompt to paste into the agent you
ticked. It names the `stackbone-coder` skill and tells the agent the piece is
already scaffolded, so the agent opens with the interview instead of a second
`init`:

```text
Your coding agent
  Open your coding agent in the workspace and paste:

  Use the stackbone-coder skill. The "my-workspace" agent is already
  scaffolded in this workspace, so skip the scaffolding: interview me
  about what it should do, then wire it up.
```

### Choosing without the prompt

| Flag              | What it does                                                                     |
| ----------------- | -------------------------------------------------------------------------------- |
| `--agents <list>` | Comma-separated agent ids, e.g. `--agents claude-code,cursor`. Skips the prompt. |
| `--no-agents`     | Sets up nothing and asks nothing. It overrides `--agents` when you pass both.    |

The ids are `claude-code`, `cursor`, `github-copilot`, `gemini-cli`,
`windsurf`, `cline` and `codex`. A misspelled one fails the command rather than
installing the rest.

> [!WARNING] Non-interactive runs set up nothing by default
> With `--json`, `-y`, no terminal, or `CI` set in the environment, there is
> nobody to answer the prompt, so `init` and `link` set up no coding agents at
> all.
> Pass `--agents <list>` to get them in a script or a container.

### Installing the skills by hand

In a repository where you have not run `stackbone init` or `stackbone link`,
or after `--no-agents`:

```bash
pnpm dlx skills add stackbone/stackbone-skills --copy
```

Or through the Claude Code marketplace, where the plugin also registers the
[MCP server](#give-your-agent-these-docs) for you:

```bash
/plugin marketplace add stackbone/stackbone-skills
/plugin install stackbone
```

## Update the skills

Re-run `stackbone init` or `stackbone link`, or one of the
[by-hand commands](#installing-the-skills-by-hand), to pick up newer skills
where they are already installed.

> [!NOTE] Do not hand-edit the installed copies
> The next install overwrites them. File corrections against the
> [stackbone-skills repository](https://github.com/stackbone/stackbone-skills)
> instead.

## Give your agent these docs

The skills teach your agent how Stackbone works. This site is the reference it
reads when it needs a detail. You can hand it over in two ways.

### As an MCP server

`https://docs.stackbone.ai/mcp` serves this whole site over the Model Context
Protocol. It is public, so there is no key to configure and nothing to install.
The prompt above wires it up for you; the block below is the fallback for a
repository without Stackbone, an agent we do not list, or a run you skipped
with `--no-agents`. `stackbone docs` prints the same details.

<details class="wiki-panel">
<summary>Add it by hand.</summary>

In Claude Code:

```bash
claude mcp add --transport http stackbone-docs https://docs.stackbone.ai/mcp
```

In Cursor (`.cursor/mcp.json`) and most other clients that read a JSON config:

```json
{
  "mcpServers": {
    "stackbone-docs": {
      "type": "http",
      "url": "https://docs.stackbone.ai/mcp"
    }
  }
}
```

The field names differ by client, and a wrong one parses without complaining and
then never connects. VS Code keys its map `servers` rather than `mcpServers`;
Gemini CLI reads `httpUrl` and treats `url` as an SSE endpoint; Windsurf reads
`serverUrl`; Cline spells the transport `streamableHttp`. In Codex the same
thing is a TOML table:

```toml
[mcp_servers.stackbone-docs]
url = "https://docs.stackbone.ai/mcp"
```

</details>

Your agent gets three tools:

| Tool          | What it does                                                                                              |
| ------------- | --------------------------------------------------------------------------------------------------------- |
| `search_docs` | Asks a question in plain words and gets back the pages that answer it, best first, with a matching quote. |
| `get_doc`     | Reads one page in full, code samples included.                                                            |
| `list_docs`   | Lists the table of contents, so the agent can see what exists before it searches.                         |

The server is read-only and holds no state between calls.

### As plain text files

For an agent that has no MCP support but can fetch a URL:

| File                                      | What it holds                                                                         |
| ----------------------------------------- | ------------------------------------------------------------------------------------- |
| `https://docs.stackbone.ai/llms.txt`      | The index: every page with its one-line description and a link to its markdown.       |
| `https://docs.stackbone.ai/llms-full.txt` | Every page of this site in one file. It is around 700 KB, so expect a large download. |

Any page is also readable as raw markdown on its own. Take the page address,
put `/content` in front of it and `.md` on the end. The page you are reading is
at `https://docs.stackbone.ai/content/docs/home/get-started/coding-agents.md`.