Rapidcraft

Intent-first scaffolding for MCP-aware AI app materialization.

Use Rapidcraft to scaffold an AI-ready project blueprint that MCP-aware tooling can turn into a production React application.

What The CLI Generates

rapidcraft init creates a project folder with a contract-aligned JSON manifest.

It does not generate React source files directly.

The generated rapidkit.template.json is the source of intent used by AI agents together with RapidKit MCP contracts.

Quick Start

Run from any folder, including an empty folder.

No npm init or yarn init is required before running the CLI.

npx rapidcraft@latest init my-product --preset enterprise-dashboard

Alternative package manager launchers:

pnpm dlx rapidcraft@latest init my-product --preset operations-console
yarn dlx rapidcraft@latest init my-product --preset enterprise-dashboard

Global install is optional:

npm install -g rapidcraft
rapidcraft init my-product --preset enterprise-dashboard

Presets

Current official presets:

enterprise-dashboard
operations-console

List available presets:

rapidcraft list-presets

Generated Output

Expected scaffold output:

my-product/
.mcp.json
AGENTS.md
package.json
rapidkit.template.json

The generated project includes:

package.json with dependencies for @rapidset/rapidkit and @rapidset/rapidmcp
root scripts mcp:start and mcp:help
post-scaffold dependency installation (unless --skip-install is passed)
.mcp.json — MCP client config that wires the local RapidKit MCP server so MCP-aware editors (Claude Code, Cursor) auto-attach when the project opens (omit with --no-mcp-config)
AGENTS.md — onboarding doc the AI agent reads first: explains the blueprint, the hard constraints (scaffoldContainsReactCode: false, useRapidKitMCP: true), which MCP tools to call, and a suggested implementation order

The manifest includes:

routes and page intent
required RapidKit component surfaces
integration boundaries (auth, API style, validation)
generation constraints for AI workflows

VS Code Developer Workflow

For teams using VS Code (or Claude Code, Cursor, or any MCP-aware editor), the typical flow is:

Run rapidcraft init to generate the blueprint, AGENTS.md, .mcp.json, package.json, and install dependencies.
Open the generated folder in your editor. The bundled .mcp.json auto-wires the RapidKit MCP server — no manual MCP configuration needed.
Point your AI agent at AGENTS.md; it orients the agent on what to build, the blueprint constraints, and which MCP tools (get_component_contract, validate_scaffold, etc.) to call.
Let the agent materialize the app from rapidkit.template.json plus the MCP contract surface.
Run standard quality gates (lint, typecheck, test, build) in the generated app repository.

CLI vs Traditional Bootstrap

When teams compare Rapidcraft with classic code-first scaffolding (for example direct Vite or Next bootstrap), the key difference is where architecture decisions are enforced.

Area	Traditional Bootstrap	Rapidcraft
Initial output	Runnable app code immediately	Intent blueprint (`rapidkit.template.json`)
Framework/runtime	Selected and materialized immediately	Selected during AI materialization step
AI role	Optional assistant after code exists	Primary implementation path from manifest + contracts
Governance timing	Mostly during PR reviews and refactors	Shifted left into preset contracts and manifest constraints
Standardization	Template quality + team discipline	Contract-driven generation and MCP context

Practical interpretation for VS Code teams:

if you prioritize immediate runnable code, traditional bootstrap feels faster initially
if you prioritize repeatable enterprise structure and policy alignment, Rapidcraft reduces long-term drift

MCP Integration

Scaffolded projects (recommended path)

Projects created by rapidcraft init already include .mcp.json at the project root pointing at the locally-installed @rapidset/rapidmcp. MCP-aware editors (Claude Code, Cursor, Claude Desktop) pick it up automatically when the project opens. No additional client configuration is required — just open the folder.

If you manage MCP configuration centrally and don’t want the per-project file, pass --no-mcp-config to rapidcraft init.

Manual setup (monorepo / development)

When working against a sibling checkout of rapidmcp rather than the published package:

pnpm --dir ../rapidmcp mcp:start -- --root "$PWD"

Then configure your MCP-capable client to use stdio with:

command: pnpm
args: --dir /absolute/path/to/rapidmcp mcp:start -- --root /absolute/path/to/rapidkit

See /MCP-SERVER for complete setup examples.

Vite And Runtime Materialization

The current CLI model is intent-first.

That means rapidcraft init does not directly run Vite scaffolding.

Vite (or another runtime choice) is selected when AI materializes the application from rapidkit.template.json using RapidKit MCP context.

Recommended Team Policy

To keep generation predictable in enterprise environments:

treat rapidkit.template.json as the project intent contract
avoid manual drift between manifest intent and generated code
use MCP contract tools as the source of truth during generation
enforce runtime quality gates in the generated application repository

Troubleshooting

Unknown preset

Run:

rapidcraft list-presets

Then retry with a valid --preset value.

Target directory is not empty

Choose a new output name or an empty target directory.

Don’t want a per-project MCP config

Use --no-mcp-config to skip writing .mcp.json into the scaffold. The scaffold’s mcp:start script still works; only the editor auto-attach hook is omitted.

Need runnable code immediately

Use your AI materialization step right after scaffold generation. rapidcraft init is designed to produce the blueprint, not final app code.

Access Control Theming