AI Agent guides
URL-addressable runbooks an AI coding assistant can follow end-to-end — install the SDK, scan your code, push keys, ship a flag, run an experiment. Hand the agent a link, answer one auth prompt, watch it work.
Hand it to an AI agent. Done in minutes.
Plain-MDX runbooks at stable URLs, designed to be followed by Claude Code, Cursor, Windsurf, OpenCode, and anything else that speaks MCP. The agent calls typed ShipEasy tools — never your shell, never your secrets — and stops only when a human is required.
ShipEasy ships every product behind a typed MCP server (shipeasy-mcp). The CLI installs it into your AI assistant's config, the agent discovers the tools, and these guides tell the agent the right sequence of calls to make for a given workflow. You answer one browser auth prompt; the agent does the rest.
Why URL-addressable runbooks
Stable URL, current content→
The guide URL never changes. The content evolves with the platform — new tools, new defaults, new framework support — and the next agent that loads it gets the current version. No prompt drift, no stale snippets in your repo.
Readable by humans too→
These pages are not packaged prompts or hidden system messages. Open them in a browser, skim the steps, decide whether to delegate. Same content the agent sees.
Typed tools, not shell→
Every action is a typed tool call (i18n_codemod_apply, exp_create_gate
, …) with a JSON-Schema input. The agent can't fabricate flags, leak credentials, or wander
off into rm -rf territory.
Forkable for your team→
Your team has conventions — naming, source roots, review steps. Fork a guide, host it on your own docs site, point your agents at that URL. The MCP tools and shapes are public.
How it works
Install the MCP server
The CLI ships a one-shot installer that writes the right MCP config for whichever assistants it finds on your machine — ~/.claude/settings.json, .cursor/mcp.json, .windsurf/mcp.json.
npm install -g @shipeasy/cli
shipeasy mcp installUnder the hood it registers npx -y @shipeasy/mcp@latest as the shipeasy MCP server. The binary is shipeasy-mcp; it runs locally over stdio, never as a hosted endpoint.
Log in once
shipeasy loginThe CLI runs an OAuth device-code flow against the ShipEasy worker (/auth/device/*) and stores a long-lived credential at ~/.shipeasy/credentials. The MCP server reads from the same file. The agent never sees your token — every tool call attaches the credential server-side.
Hand the agent a guide URL
Open your AI assistant in your project and say something like:
"Follow https://docs.shipeasy.ai/llms/i18n-strings to onboard this project to ShipEasy."
The agent fetches the page, reads the steps, and starts calling the appropriate mcp__shipeasy__* tools in order. It pauses for human input only at the points the runbook marks with STOP (typically: browser auth, ambiguous codemod cases).
What the MCP server exposes
The shipeasy-mcp binary advertises a typed tool surface grouped by product. Every guide on this site is a recipe for chaining these tools:
{ authenticated: boolean, user, project }. First call in every workflow — if it returns false, the agent must ask the human to run shipeasy login.frameworks, entry_points, and shipeasy.{i18n_sdk, loader_script_tag}. Lets the agent skip framework guesswork.profiles, keys, gates, configs, experiments. Cheap to call; the agent uses these to verify state between mutations.install_loader, create_profile, scan_code, codemod_preview, codemod_apply, push_keys, create_key, translate_draft, validate_keys, publish_profile, discover_site.create_gate, create_config, create_experiment, start_experiment, stop_experiment, experiment_status.MCP tools mutate ShipEasy state through the public API. Anything that touches your filesystem (the
codemod, the loader install) runs the local CLI binary, which prints what it's about to do
and respects --dry-run. There is no exec_arbitrary_command tool.
Available guides
Planned guides
These are scaffolded against the same MCP surface and ship as the underlying products stabilise. Watch this index — when the link goes live, it works.
Gate an existing feature→
Pick a code path, create the gate, wrap the call site, default-off, ship. Optional rollout to
5%. Uses exp_create_gate + get_sdk_snippet.
Run your first experiment→
Define the metric, create the universe, set traffic split, instrument the exposure event. Uses
the full exp_* chain plus experiment_status for the read-back.
Migrate from LaunchDarkly→
Pull flag definitions via LD's API, map to gates + targeting rules, generate the codemod that swaps SDK call sites, run side-by-side in one environment for sign-off.
Migrate from Statsig→
Statsig flags + experiments → ShipEasy gates + universes. Preserves bucketing where possible (deterministic by user_id) and flags any incompatible targeting expressions for human review.
Write your own guide
The guides are plain MDX. If your team has conventions — a specific source root, a review step, a Slack channel that needs pinging on publish — fork one, edit it, host it. The agent doesn't care where the URL points; it cares that the page describes a sequence of MCP tool calls.
Start from an existing guide
Copy content/docs/llms/i18n-strings.mdx from the docs
repo. It's
the canonical pattern: numbered steps, explicit tool names, explicit JSON args, explicit failure
handling.
Mark every human stop
Use the literal token STOP in step titles where the agent must wait — browser auth,
codemod approval, anything that mutates production. Agents are trained to honour this.
Reference tools by their MCP name
Use the canonical tool name (i18n_codemod_apply, not "the apply step").
Show the full JSON arg shape. Agents pattern-match on these.
Host it on a stable URL
Anywhere the agent can fetch — your docs site, a GitHub raw URL, a gist. Hand the URL to your team and to your agents.
Resist the urge to paste a guide into CLAUDE.md or your project's AGENTS.md. The MCP tool
surface evolves; the URL stays current; a copy goes stale immediately. Reference the URL,
don't inline it.
Try the i18n runbook on a real project.
Install the CLI, install the MCP server, log in once, paste the URL into your AI assistant. Five minutes from a hardcoded-English app to a published source profile.