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 repository and follow the Agent Skills Open Standard.

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, 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`	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`	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`	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`	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 and CLI docs first.

Set up your coding agents

The prompt in `init` and `link`

Run stackbone init or stackbone 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:

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.

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:

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

Or through the Claude Code marketplace, where the plugin also registers the MCP server for you:

/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, to pick up newer skills where they are already installed.

Do not hand-edit the installed copies

The next install overwrites them. File corrections against the stackbone-skills repository 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.

Add it by hand.

In Claude Code:

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:

{
  "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:

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

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.