Stitch Skills: Agent Skills for the Stitch MCP Server

What Stitch Skills Solves, and Who It Is For

Stitch is Google's design tool, and the Stitch MCP server exposes it to coding agents. The gap this repository fills is the instruction layer: an MCP server gives an agent tools, but not the knowledge of which sequence of calls produces a design system, a React component tree, or a static HTML snapshot. Stitch Skills is that sequence written down, packaged as Agent Skills following the agentskills.io open standard.

The audience is narrow and specific. You are a frontend or design engineer working in an agent that supports skills discovery, and your team already uses Stitch as the design surface. The README lists Codex, Antigravity, Gemini CLI, Claude Code, Cursor, and OpenCode (manual install) as compatible agents. If you do not use Stitch, nothing here applies to you, because every skill is a wrapper around Stitch MCP calls rather than a standalone utility.

How the Skill, Plugin and MCP Layers Fit Together

The repository layout is the architecture. At the top level there is `.agents/`, `.github/`, `plugins/`, plus the usual `CONTRIBUTING.md`, `LICENSE`, `README.md` and `SECURITY.md`. The `.agents/plugins` path is what the Codex marketplace command checks out, and `plugins/` holds the three plugin groups: `stitch-design`, `stitch-build` and `stitch-utilities`.

Each plugin contains a `skills/` directory, and each skill is a folder such as `plugins/stitch-design/skills/generate-design`. The skill name in the README uses a `stitch::` prefix, for example `stitch::code-to-design` and `stitch::react-components`. That prefix is a naming convention in the frontmatter, not a package on a registry.

The data flow is one-directional per skill. A design skill reads local input (frontend source, a running URL, an image) and writes into Stitch through the MCP server. A build skill reads Stitch screens and writes code back into your project. `stitch::extract-static-html` inlines CSS and images from a running web app; `stitch::upload-to-stitch` pushes the resulting asset into a Stitch project. The MCP server holds the credentials and the project state; the skill holds the procedure.

Installing Stitch Skills for Codex, Claude Code and Cursor

The README recommends installing plugins rather than individual skills. For Codex, you register the marketplace with a sparse checkout that limits the clone to the plugin paths. The `--sparse` flags are optional and can be omitted to pull the whole repository.

codex plugin marketplace add google-labs-code/stitch-skills --ref main \
  --sparse .agents/plugins \
  --sparse plugins/stitch-design \
  --sparse plugins/stitch-build \
  --sparse plugins/stitch-utilities

After the marketplace is registered you install any combination of `stitch-design`, `stitch-build` and `stitch-utilities`. The same registration can be done through the Codex UI under Settings, Plugin Marketplaces, Add, with the source set to the GitHub URL and the git ref set to `main`.

For Claude Code and Cursor the README uses a different installer. Claude Code installs into the current project, Cursor into the current workspace.

npx plugins add google-labs-code/stitch-skills --scope project --target claude-code

npx plugins add google-labs-code/stitch-skills --scope workspace --target cursor

Selective installation is possible with `npx skills add google-labs-code/stitch-skills`, but the README carries an explicit warning that Stitch Design Skills often have inter-dependencies, so a partial install must include the dependencies of whatever you pick. Both `npx plugins --help` and `npx skills --help` print the available options.

Before any of this produces output, the Stitch MCP server has to be configured and running in the agent environment, following the setup page at stitch.withgoogle.com/docs/mcp/setup. That page is where the endpoint and credentials come from.

A First Real Use: Pushing a Dashboard into a Stitch Project

The README gives prompt examples rather than a scripted tutorial, so the practical first run is a prompt to the agent after installation. The design plugin's `stitch::code-to-design` skill is described as converting frontend code such as React or Vue into a Stitch design through HTML extraction, design system handling and upload. The README's own example prompt is:

Upload the frontend code at `/path/to/dashboard` into a Stitch project named 'Dashboard-Migration-2026'.

What the reader should expect is a Stitch project populated from that path, with the design system derived from the source. The adjacent `stitch::extract-design-md` skill writes a design system document to a path such as `.stitch/DESIGN.md`, and `stitch::manage-design-system` uploads that file and applies it to screens. A minimal sequence therefore looks like extracting the design system first, then uploading screens, then applying the theme.

For the reverse direction, `stitch::react-components` converts Stitch screens into a React component system with validation and design token consistency. Its README example references a project id directly:

Convert all screens in Stitch project `projects/123` to React components.

If you are on OpenCode, none of the `npx` installers apply. You copy skill folders into a discoverable path and register the MCP server yourself in `opencode.json`:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "stitch": {
      "type": "remote",
      "url": "YOUR_STITCH_MCP_URL",
      "enabled": true
    }
  }
}

The URL is replaced with the endpoint from the Stitch MCP setup flow, and the credentials and environment variables from that guide still apply.

Where Stitch Skills Breaks: OpenCode Naming and the MCP Dependency

Two limitations are documented and both are load-bearing.

The first is the MCP dependency. The prerequisites section is unambiguous: these skills require the Stitch MCP server to be configured and running in the agent environment. There is no offline mode, no local fallback, and no partial functionality if the server is unreachable. The README does not document what a skill does when an MCP call fails, and it does not describe rollback for a partially uploaded project. If you need deterministic, auditable design-to-code conversion without a hosted service in the loop, this is the wrong tool.

The second is OpenCode's naming rules. OpenCode requires the skill `name` frontmatter to be lowercase kebab-case and to match the directory name. Skills that use `stitch::` names or other non-kebab forms need the `name` field and the folder renamed before OpenCode will load them, and extra frontmatter such as `allowed-tools` is ignored. The README also notes that tool names inside skill instructions may differ from OpenCode builtins, listing `webfetch` and `bash` where other agents use `web_fetch` and `run_command`, and advises preferring the OpenCode names when adapting a skill. That is manual porting work, not an install.

A third constraint is softer but real: selective installation is discouraged because of inter-dependencies, which pushes most users toward installing all three plugins even when they want one skill.

Stitch Skills Compared with a Plain MCP Setup

The honest alternative is not another skills library. It is using the Stitch MCP server on its own, with no skills installed, and writing your own prompts each session.

The difference is where the procedure lives. With a bare MCP setup, the agent sees the Stitch tools and you describe the workflow in every conversation: extract the design system, upload the screens, apply the theme, convert to components. With Stitch Skills, that workflow is a named skill the agent can discover and invoke, with the README's prompt examples showing the intended phrasing. You trade a one-time install and a dependency on the repository's conventions for not re-explaining the same sequence.

The trade runs the other way too. A bare MCP setup has no `stitch::` naming to reconcile, no plugin marketplace registration, and no inter-dependency warning when you want one capability. If your use of Stitch is exploratory rather than a repeated pipeline, the skills layer adds ceremony without removing much work. The repository is at v1.0 as of 2026-05-18, following a v0.1 release on 2026-03-04, and the last push to `main` was on 2026-08-17, so the conventions are still settling.

Maintenance, Licence and Upgrade Cost

The repository is not archived, and the last push was on 2026-08-17. Two releases exist: v0.1 on 2026-03-04 and v1.0 on 2026-05-18. The README does not document a changelog, a deprecation policy, or a migration path between the two releases, so an upgrade from v0.1 to v1.0 has to be inferred from the repository rather than read from a guide.

The practical upgrade cost sits in the skill folders. Because the Codex install pins `--ref main`, a marketplace registered that way follows the branch rather than a tag. Teams that need reproducibility should pin a ref at registration time instead of tracking `main`, though the README only shows `main` in its examples. On OpenCode the cost is higher, since any rename you applied to satisfy kebab-case has to be reapplied when the upstream folder names change.

The licence is Apache-2.0, which permits commercial and modified use and includes an explicit patent grant. Apache-2.0 also requires that modified files carry prominent notices and that the licence text be included. If you fork the skills to rename them for OpenCode, those obligations follow the fork. This is a description of the licence terms, not legal advice; check with your own counsel for your situation.

Editorial conclusion

Adopt Stitch Skills if you already have the Stitch MCP server configured and want an agent to turn Stitch screens into React components or push frontend code back into a Stitch project. Do not adopt it if you have no Stitch MCP endpoint, or if you need OpenCode support out of the box, since its naming rules conflict with several skill names and the README asks you to rename folders and frontmatter by hand. Before installing, verify two things: that your agent is listed as compatible, and that the Stitch MCP server is registered with working credentials, because every skill in this repository is inert without it.

Frequently asked questions

Official sources

1. google-labs-code/stitch-skills on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases