Build with an agent

Every command on this site runs the same two ways: with flags, for scripts and agents, and guided, when you leave the flags off. That is what makes an agent a first-class way to build an extension. This page lists what to install. All three surfaces run the CLI, so it goes on your PATH first:

curl -fsSL https://get.tappify.ai | sh
tappify login

On Node 20 or newer, npm i -g @tappify/cli installs the same CLI.

Tappify Extension Tools for Claude Code

This Claude Code plugin is for extension developers. It does not let workspace members access or operate Tappify through Claude. Install it from its GitHub repository:

/plugin marketplace add tappify-dev/claude-code-extension-tools
/plugin install extension-tools@tappify

Then restart Claude Code, or run /reload-plugins. To load a local checkout instead:

/plugin marketplace add /path/to/claude-code-extension-tools
/plugin install extension-tools@tappify

Without installing it, the first command below loads the checkout for one session and the second validates its manifest:

claude --plugin-dir /path/to/claude-code-extension-tools
claude plugin validate /path/to/claude-code-extension-tools

It brings five Claude Code skills, one command, and the MCP server below.

Claude Code skill	Claude loads it when
`building-tappify-extensions`	Writing or changing an extension, or deciding what one is allowed to do
`adding-a-contribution`	Adding a contribution of any kind, or fixing one whose files, manifest entry and generated types are out of step
`testing-an-extension`	Writing or fixing tests for a component, a procedure or a server handler
`publishing-an-extension`	Publishing a release, writing notes, changing visibility, or reading a review outcome
`debugging-extension-load-failures`	An extension does not render in the host

/extension-tools:new-extension scaffolds an extension, runs it on the sandbox project, and publishes the first release.

The MCP server

The CLI serves it:

tappify mcp

It speaks MCP over stdin and stdout, so any client that runs a command can use it. Every human line goes to stderr, and the server ends when its client closes stdin. The plugin declares it, so the extension developer does nothing. For a client you configure yourself:

{
  "mcpServers": {
    "tappify": {
      "command": "tappify",
      "args": ["mcp"]
    }
  }
}

It signs in as you: the same credentials tappify login wrote.

MCP operation	Does	Takes	Result
`extension_validate`	Checks an extension’s manifest against the schema and the registry	`cwd`	`id`, `valid`, `checks`
`extension_doctor`	Runs every check the Tap Store runs, and reports what would block a release	`cwd`; `fix` applies the fixes that cannot change behaviour	`id`, `checks`, `errors`, `warnings`, `passed`, `fixed`
`extension_types`	Regenerates `src/tappify.d.ts` from the manifest and its schemas	`cwd`	`file`, `schemas`
`extension_registry`	Lists the host pages, slots, charts, tables, scopes, categories and events an extension can use	`refresh` fetches the registry instead of reading the cached copy	the registry
`extension_status`	Reports an extension’s live release, pending release, review timeline and install count	`cwd`	`id`, `live`, `pending`, `timeline`, `installCount`
`extension_add`	Adds one contribution to an extension: the manifest entry, its files and its scopes	`cwd`; `kind` as the CLI names it; `name`; `options`, the kind’s flags keyed the way the CLI names them	`kind`, `id`, `files`, `scopesAdded`
`extension_publish`	Publishes a release, after showing what would ship and asking for confirmation	`cwd`; `notes`, what changed, up to 1000 characters; `confirm`	`needsConfirmation` and a summary, or `id`, `status`, `releaseId`, `bytes`, `entries`, and `pending`, the diff against the live release, when a release that already has one goes to review
`docs_search`	Searches this documentation and returns the pages that answer a question	`query`; `limit`, 1 to 10	`results`, five pages with an excerpt each unless `limit` says otherwise

Every result carries ok: true beside the keys above, which are the keys the matching command’s --json prints where a command matches. A failure is { "ok": false, "error": { "what": …, "why": …, "fix": … } }. cwd is optional everywhere it appears, and falls back to the directory the server started in. extension_doctor runs the whole set: the manifest and registry checks, then your build, typecheck, lint, tests and the axe pass. extension_validate runs only the four that need no build and no network beyond the cached registry, so it is the one to call in a loop while you write the manifest. extension_publish never publishes on the first call. It runs the project’s build script when there is one, then the checks without the tooling set — no typecheck, lint, tests or axe pass, which is why extension_doctor comes first. Called with confirm: false it returns what would ship — the bundle size, the entries, the scopes, the notes — and only confirm: true uploads. Describing a release registers nothing: the extension id is claimed, and Tappify’s own checks run against the bundle, only on the call you confirm. notes is required on both calls, up to 1000 characters.

The VS Code extension

It is not on the Marketplace yet. Build the vsix from the checkout and install that:

cd vscode-tappify
pnpm install
pnpm package
code --install-extension tappify-0.1.0.vsix

It validates tappify.extension.json against the published schema and completes every field. A manifest with a $schema line uses the hosted schema; one without falls back to the copy bundled in the extension, so the file validates with no network. Twenty-one snippets write manifest entries under the tap- prefix: tap-manifest for a whole manifest, and one for each contribution kind, from tap-widget to tap-work. Five commands run the CLI in a terminal named Tappify, reused across commands, in the first folder of the workspace:

Command	Id	Runs
Tappify: Start the dev server	`tappify.extension.dev`	`tappify extension dev`
Tappify: Run the checks	`tappify.extension.doctor`	`tappify extension doctor`
Tappify: Add a contribution	`tappify.extension.add`	`tappify extension add <kind>`
Tappify: Regenerate the types	`tappify.extension.types`	`tappify extension types`
Tappify: Publish a release	`tappify.extension.publish`	`tappify extension publish`

Add a contribution asks which kind in the editor and passes it on the command line. Publish asks for nothing in the editor: the CLI asks for the release notes in the terminal, where what you type goes to the CLI and not to your shell.

What a model reads

File	Is
`/llms.txt`	Every page on this site, one line each, with its description
`/llms-full.txt`	Every page, in full, as one document
`AGENTS.md` in the documentation repository	Where to start, and the rules for writing these pages

Any page also serves its Markdown source: add .md to the URL.

Rules an agent should hold

An agent building an extension is bound by the same rules a person is, and two of them are worth stating outright:

The registry is the source of truth for pages, slots, charts, tables, scopes, categories and events. Read it with extension_registry; a guessed slot fails the checks.
src/tappify.d.ts is generated. Change the manifest or a schema and rerun tappify extension types; a hand edit is overwritten by the next command.

What extensions can never do is the rest.

Start

Build

Test

Publish

Reference

Tappify Extension Tools for Claude Code

The MCP server

The VS Code extension

What a model reads

Rules an agent should hold

​Tappify Extension Tools for Claude Code

​The MCP server

​The VS Code extension

​What a model reads

​Rules an agent should hold

Tappify Extension Tools for Claude Code

The MCP server

The VS Code extension

What a model reads

Rules an agent should hold