boogy
boogy://you/services/hello

Vibe whole apps
into production.

Vibe-code a frontend, an API over REST, JSON-RPC, MCP, or protobuf RPC, and a store that scales itself — Boogy runs it all as real production services: interconnected, fast, and pay-per-use.

Every service gets a relational, ACID data store that scales on its own and bills per use — and a single transaction can span calls across services.

You don’t start by learning an SDK. Install the plugin, then ask for what you want — it carries the skills, the platform tools and the rules, and your agent does the building.

 the whole setup
# in your terminal
$ claude plugin marketplace add Boogy-ai/boogy-superpowers
$ claude plugin install boogy-superpowers

# then inside Claude Code — nothing activates until you do
/reload-plugins

# that's the setup. now just ask:
“build me a link shortener with a web page, and deploy it”

Not on Claude Code? Point any MCP-capable agent at the server instead — claude mcp add boogy https://api.boogy.ai/mcp — or read boogy.ai/llms.txt and follow it.

// what a service gets

Surfaces

REST, JSON-RPC, MCP tools and protobuf RPC — Connect, gRPC-Web and native gRPC over one mount. openapi.json and openrpc.json are generated and served for you.

Data

A private store with real relations and transactions. Declare models in Rust; indexes and columns reconcile themselves on deploy.

Frontend

Ship TypeScript or JS source — the platform transpiles and serves it. No Node, no bundler, no build step on your machine. Static site, full-stack, or backend-only.

Identity

Accounts, “Sign in with Boogy” for your users, a different pseudonym per service so apps can’t correlate them, API keys, scopes, and delegation between services.

Money

Charge per route execution against a prepaid ledger — reserved before the call, settled only if it succeeds. Publish a module and earn a share of what instances of it generate.

And the rest

Background jobs, real-time channels, streaming responses, file storage, cryptographic signing, OAuth connections to your users’ third-party accounts, and LLM completions across providers.

Capabilities are deny-by-default: a service reaches nothing it hasn’t declared in its manifest, and ingress mode, rate limits and CORS are enforced by the host rather than by your code.

// agents — start here

If you're a coding agent, do this first

On Claude Code? Install the plugin — it bundles the build skills (auto-discovered), wires the Boogy MCP (sign-in + host-truth validation as tools), and sets the build contract, in one step. On another agent, read boogy.ai/llms.txt (the bootstrap) and follow it. Either way, the steps are:

  1. Install the plugin — this is the setup. claude plugin marketplace add Boogy-ai/boogy-superpowers, then claude plugin install boogy-superpowers. It bundles the skills, wires the Boogy MCP, and adds the onramp gate. Then tell the user to run /reload-plugins — none of it activates until they do, and there is no error to tell you that; it simply behaves as though the plugin were not installed. Not on Claude Code? Add the MCP (claude mcp add boogy https://api.boogy.ai/mcp), or install the CLI (cargo install --locked --git https://github.com/Boogy-ai/boogy-sdk boogy-cli) and vendor the skills with boogy skills install.
  2. Authenticate the user. Run the login tool (or boogy login) — it prints a link. Ask the user to click it, sign in, then return; the token comes back automatically. A first-time user picks a handle — 4 to 30 characters, lowercase [a-z0-9-], counted after the platform fixes what it can (My_App → my-app). It becomes their subdomain, at https://<handle>.boogy.app/<mount>/…, so they choose it, never you.
  3. Work strictly from the skills. Invoke them (start with using-boogy) — never summarize or “distill” them into your own words. If a step is blocked, stop and ask the user; don’t work around it.
  4. Build & deploy. The skills carry the workflow; boogy deploy ships it (the CLI or /v1 API does the deploy — the MCP can’t).
// routes
/plugin

The plugin — start here

One install is the whole setup: 40 build skills your agent follows, the Boogy MCP wired as tools (sign-in, host-truth validation), and the gate that keeps it working from the skills instead of from guesswork. claude plugin install boogy-superpowers, then /reload-plugins.

→
/mcp

MCP server — without the plugin

For agents that aren’t Claude Code. https://api.boogy.ai/mcp — anonymous, no install; the plugin wires this for you already. Guidance (get_started, get_skill), host-truth validation (validate_manifest, check_service), and sign-in (login shows the user a link to click, then returns a token — no CLI needed).

→
/llms-full.txt

Agent context — llms-full.txt

The agent bootstrap: the setup contract, core concepts, and the three deployment shapes. The build workflow itself lives in the installed skills — invoke them, don't work from a copy. If you're an AI agent, read https://boogy.ai/llms-full.txt first.

→
/boogy-sdk/docs

API reference

Rustdoc for every type, macro, router, and guard in the SDK.

→
/boogy-sdk

SDK & quickstart

Router, typed handlers, wit_glue!, store helpers, the boogy CLI, and a copy-to-start template.

→
/boogy-web

Web SDK — Sign in with Boogy

The browser SDK for apps built on Boogy — authenticated requests to your services, user sign-in, and session management, in one fetch().

→
/superpowers

Agent skills

Expert build workflows your coding agent installs and follows — auto-discovered by Claude Code.

→
/frontends

Ship a UI with no build step

Point a manifest at a directory of TypeScript, HTML and CSS. The platform transpiles it at deploy, content-addresses every asset, and serves them itself — your wasm only handles the API routes. Static site, full-stack, or backend-only, from the same manifest.

→
/catalog

Service catalog

Provisionable building blocks — send email, take payments — deployed into your tenant, wired to your own keys.

→
/platform

boogy.ai

Deploy, observe, and manage your services — the full platform and the story behind it.

→